enhancement: better compilation command

Author: dafuga

src/commands/compile.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-console */
 import {Command} from 'commander'
 import {execSync} from 'child_process'
-import {existsSync, readdirSync} from 'fs'
-import {basename, extname, join, resolve} from 'path'
+import {existsSync, mkdirSync, readdirSync, readFileSync, statSync} from 'fs'
+import {basename, dirname, extname, join, relative, resolve} from 'path'
 import {checkLeapInstallation} from './chain/install'
 
 /**
@@ -25,19 +25,55 @@ export async function compileContract(file: string | undefined, outputDir: strin
     // Ensure cdt-cpp is installed
     await ensureCdtCppInstalled()
 
-    console.log(`Compiling ${files.length} file(s) to ${absoluteOutputDir}\n`)
+    console.log(`Compiling ${files.length} file(s)...\n`)
 
     for (const filePath of files) {
-        await compileSingleFile(filePath, absoluteOutputDir)
+        await compileSingleFile(filePath, currentDir, absoluteOutputDir)
     }
 
     console.log('\nCompilation complete!')
 }
 
+/**
+ * Recursively find all .cpp files in a directory
+ */
+function findCppFilesRecursive(dir: string, files: string[] = []): string[] {
+    try {
+        const entries = readdirSync(dir, {withFileTypes: true})
+
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name)
+
+            // Skip hidden directories and common build/output directories
+            if (entry.isDirectory()) {
+                if (
+                    entry.name.startsWith('.') ||
+                    entry.name === 'node_modules' ||
+                    entry.name === 'build' ||
+                    entry.name === 'dist' ||
+                    entry.name === 'lib'
+                ) {
+                    continue
+                }
+                findCppFilesRecursive(fullPath, files)
+            } else if (entry.isFile() && extname(entry.name) === '.cpp') {
+                files.push(fullPath)
+            }
+        }
+    } catch {
+        // Ignore permission errors and other filesystem errors
+    }
+
+    return files
+}
+
 /**
  * Get list of files to compile
  */
-async function getFilesToCompile(file: string | undefined, currentDir: string): Promise<string[]> {
+export async function getFilesToCompile(
+    file: string | undefined,
+    currentDir: string
+): Promise<string[]> {
     if (file) {
         const filePath = resolve(currentDir, file)
         if (!existsSync(filePath)) {
@@ -49,10 +85,8 @@ async function getFilesToCompile(file: string | undefined, currentDir: string):
         return [filePath]
     }
 
-    // Get all .cpp files in current directory
-    const files = readdirSync(currentDir)
-        .filter((f) => extname(f) === '.cpp')
-        .map((f) => join(currentDir, f))
+    // Recursively find all .cpp files in current directory and subdirectories
+    const files = findCppFilesRecursive(currentDir)
 
     return files
 }
@@ -104,18 +138,217 @@ function isCdtCppInstalled(): boolean {
     }
 }
 
+/**
+ * Find the contract root directory by walking up from the source file
+ * Looks for common contract directory structures
+ */
+export function findContractRoot(sourceFile: string): string {
+    let currentDir = dirname(resolve(sourceFile))
+    const root = resolve('/')
+
+    // Walk up the directory tree looking for contract structure indicators
+    while (currentDir !== root) {
+        // Check for common contract directory patterns
+        const hasInclude = existsSync(join(currentDir, 'include'))
+        const hasSrc = existsSync(join(currentDir, 'src'))
+        const hasInc = existsSync(join(currentDir, 'inc'))
+        const hasHeaders = existsSync(join(currentDir, 'headers'))
+
+        // If we find include directories or src directory, this might be the contract root
+        if (hasInclude || hasSrc || hasInc || hasHeaders) {
+            return currentDir
+        }
+
+        // Also check if current directory contains .cpp files (might be contract root)
+        try {
+            const files = readdirSync(currentDir)
+            const hasCppFiles = files.some((f) => extname(f) === '.cpp')
+            if (hasCppFiles && (hasInclude || hasInc || hasHeaders)) {
+                return currentDir
+            }
+        } catch {
+            // Ignore permission errors
+        }
+
+        currentDir = dirname(currentDir)
+    }
+
+    // If no contract root found, return the source file's directory
+    return dirname(resolve(sourceFile))
+}
+
+/**
+ * Auto-detect include directories
+ */
+export function detectIncludeDirectories(sourceFile: string, contractRoot: string): string[] {
+    const sourceDir = dirname(resolve(sourceFile))
+    const includeDirs: string[] = []
+
+    // Common include directory patterns
+    const patterns = [
+        join(contractRoot, 'include'),
+        join(contractRoot, 'inc'),
+        join(contractRoot, 'headers'),
+        join(sourceDir, 'include'),
+        join(sourceDir, 'inc'),
+        join(sourceDir, 'headers'),
+    ]
+
+    for (const dir of patterns) {
+        if (existsSync(dir) && statSync(dir).isDirectory()) {
+            const normalized = resolve(dir)
+            if (!includeDirs.includes(normalized)) {
+                includeDirs.push(normalized)
+            }
+        }
+    }
+
+    return includeDirs
+}
+
+/**
+ * Auto-detect resource paths (for quoted includes like #include "actions/commit.cpp")
+ */
+export function detectResourcePaths(sourceFile: string, contractRoot: string): string[] {
+    const sourceDir = dirname(resolve(sourceFile))
+    const resourcePaths: string[] = []
+
+    // Common resource directory patterns
+    const patterns = [
+        join(contractRoot, 'src'),
+        join(sourceDir, 'src'),
+        contractRoot, // Root itself might contain resources
+        sourceDir, // Source directory might contain resources
+    ]
+
+    for (const dir of patterns) {
+        if (existsSync(dir) && statSync(dir).isDirectory()) {
+            const normalized = resolve(dir)
+            if (!resourcePaths.includes(normalized)) {
+                resourcePaths.push(normalized)
+            }
+        }
+    }
+
+    return resourcePaths
+}
+
+/**
+ * Parse #include statements from source file
+ */
+export function parseIncludes(sourceFile: string): {angleBracket: string[]; quoted: string[]} {
+    const content = readFileSync(sourceFile, 'utf8')
+    const angleBracket: string[] = []
+    const quoted: string[] = []
+
+    // Match #include <...> and #include "..."
+    const includeRegex = /#include\s+[<"]([^>"]+)[>"]/g
+    let match
+
+    while ((match = includeRegex.exec(content)) !== null) {
+        const includePath = match[1]
+        if (match[0].includes('<')) {
+            angleBracket.push(includePath)
+        } else {
+            quoted.push(includePath)
+        }
+    }
+
+    return {angleBracket, quoted}
+}
+
+/**
+ * Auto-detect compilation flags based on source file and directory structure
+ */
+export function autoDetectCompileFlags(sourceFile: string): string[] {
+    const contractRoot = findContractRoot(sourceFile)
+    const includeDirs = detectIncludeDirectories(sourceFile, contractRoot)
+    const resourcePaths = detectResourcePaths(sourceFile, contractRoot)
+    const includes = parseIncludes(sourceFile)
+
+    const flags: string[] = []
+
+    // Add include directories (-I flag) if they exist
+    // These are needed for angle-bracket includes like <randomrng/randomrng.hpp>
+    if (includeDirs.length > 0) {
+        for (const dir of includeDirs) {
+            flags.push(`-I${dir}`)
+        }
+    }
+
+    // Add resource paths (-R flag) for quoted includes like "actions/commit.cpp"
+    // Only add if there are actually quoted includes in the source
+    if (resourcePaths.length > 0 && includes.quoted.length > 0) {
+        for (const path of resourcePaths) {
+            flags.push(`-R${path}`)
+        }
+    }
+
+    return flags
+}
+
 /**
  * Compile a single C++ file to WASM using cdt-cpp
  */
-async function compileSingleFile(filePath: string, outputDir: string): Promise<void> {
+async function compileSingleFile(
+    filePath: string,
+    currentDir: string,
+    outputDir: string
+): Promise<void> {
     const fileName = basename(filePath, '.cpp')
-    const wasmOutput = join(outputDir, `${fileName}.wasm`)
+    const contractRoot = findContractRoot(filePath)
+    const contractRootSrc = join(contractRoot, 'src')
+    const sourceFileAbsolute = resolve(filePath)
+    
+    // Check if source file is inside a src/ directory relative to contract root
+    // If so, strip the src/ prefix from output path
+    let relativePath: string
+    if (existsSync(contractRootSrc) && sourceFileAbsolute.startsWith(resolve(contractRootSrc))) {
+        // File is in src/ directory, calculate path relative to contract root
+        const pathFromContractRoot = relative(contractRoot, filePath)
+        // Strip 'src/' prefix if present
+        if (pathFromContractRoot.startsWith('src/')) {
+            relativePath = pathFromContractRoot.substring(4) // Remove 'src/' prefix
+        } else {
+            relativePath = pathFromContractRoot
+        }
+    } else {
+        // Use path relative to current directory (preserve structure)
+        relativePath = relative(currentDir, filePath)
+    }
+    
+    const relativeDir = dirname(relativePath)
+
+    // Calculate output path
+    let wasmOutput: string
+    if (relativeDir === '.' || relativeDir === '') {
+        // File should be output directly in output directory
+        wasmOutput = join(outputDir, `${fileName}.wasm`)
+    } else {
+        // File is in a subdirectory, preserve the structure (but without src/ prefix if stripped)
+        const outputSubDir = join(outputDir, relativeDir)
+        // Ensure the output subdirectory exists
+        if (!existsSync(outputSubDir)) {
+            mkdirSync(outputSubDir, {recursive: true})
+        }
+        wasmOutput = join(outputSubDir, `${fileName}.wasm`)
+    }
+
+    // Calculate ABI output path (same location as WASM, but with .abi extension)
+    const abiOutput = wasmOutput.replace(/\.wasm$/, '.abi')
 
     console.log(`Compiling: ${filePath}`)
     console.log(`Output: ${wasmOutput}`)
 
+    // Auto-detect compilation flags
+    const autoFlags = autoDetectCompileFlags(filePath)
+    if (autoFlags.length > 0) {
+        console.log(`Auto-detected flags: ${autoFlags.join(' ')}`)
+    }
+
     try {
-        const command = `cdt-cpp -abigen -o "${wasmOutput}" "${filePath}"`
+        const flagsStr = autoFlags.length > 0 ? `${autoFlags.join(' ')} ` : ''
+        const command = `cdt-cpp -abigen -abigen_output="${abiOutput}" ${flagsStr}-o "${wasmOutput}" "${filePath}"`
         execSync(command, {
             stdio: 'inherit',
             cwd: process.cwd(),