recon-generate 0.0.8 → 0.0.10

package/dist/index.js

@@ -163,6 +163,7 @@ async function main() {
         .option('--medusa-config <path>', 'Path to medusa json (defaults based on --name)')
         .option('--name <suite>', 'Suite name to pick config defaults (echidna-<name>.yaml / medusa-<name>.json)')
         .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
+        .option('--verbose', 'Enable verbose output for debugging')
         .action(async (opts, cmd) => {
         var _a;
         const workspaceRoot = process.cwd();
@@ -182,7 +183,7 @@ async function main() {
         const medusaConfigPath = path.isAbsolute(medusaConfigOpt)
             ? medusaConfigOpt
             : path.join(foundryRoot, medusaConfigOpt);
-        await (0, link_1.runLink)(foundryRoot, echidnaConfigPath, medusaConfigPath);
+        await (0, link_1.runLink)(foundryRoot, echidnaConfigPath, medusaConfigPath, !!opts.verbose);
     });
     program
         .action(async (opts) => {

package/dist/link.d.ts

@@ -1 +1 @@
-export declare function runLink(foundryRoot: string, echidnaConfigPath: string, medusaConfigPath: string): Promise<void>;
+export declare function runLink(foundryRoot: string, echidnaConfigPath: string, medusaConfigPath: string, verbose?: boolean): Promise<void>;

package/dist/link.js

@@ -44,9 +44,15 @@ const utils_1 = require("./utils");
 const generateHexAddress = (index) => {
     return `0xf${(index + 1).toString().padStart(2, '0')}`;
 };
-const parseLibrariesFromOutput = (output) => {
+const parseLibrariesFromOutput = (output, verbose = false) => {
+    if (verbose) {
+        console.log(`[VERBOSE] Parsing libraries from output (${output.length} chars)`);
+    }
     const usesPattern = /^\s+uses: \[(.*?)\]/gm;
     const matches = [...(0, utils_1.stripAnsiCodes)(output).matchAll(usesPattern)];
+    if (verbose) {
+        console.log(`[VERBOSE] Found ${matches.length} 'uses:' patterns`);
+    }
     const allLibraries = [];
     for (const match of matches) {
         if (match[1]) {
@@ -54,6 +60,9 @@ const parseLibrariesFromOutput = (output) => {
                 .split(',')
                 .map(lib => lib.trim().replace(/["'\s]/g, ''))
                 .filter(lib => lib.length > 0);
+            if (verbose) {
+                console.log(`[VERBOSE] Parsed libraries from match: ${libs.join(', ')}`);
+            }
             for (const lib of libs) {
                 if (!allLibraries.includes(lib)) {
                     allLibraries.push(lib);
@@ -63,11 +72,21 @@ const parseLibrariesFromOutput = (output) => {
     }
     return allLibraries;
 };
-const runCryticCompile = (cwd) => {
+const runCryticCompile = (cwd, verbose = false) => {
     return new Promise((resolve, reject) => {
-        (0, child_process_1.exec)('crytic-compile . --foundry-compile-all --print-libraries', { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (error, stdout, stderr) => {
+        const cmd = 'crytic-compile . --foundry-compile-all --print-libraries';
+        if (verbose) {
+            console.log(`[VERBOSE] Running command: ${cmd}`);
+            console.log(`[VERBOSE] Working directory: ${cwd}`);
+        }
+        (0, child_process_1.exec)(cmd, { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (error, stdout, stderr) => {
+            if (verbose) {
+                console.log(`[VERBOSE] stdout:\n${stdout}`);
+                console.log(`[VERBOSE] stderr:\n${stderr}`);
+            }
             if (error) {
-                reject(new Error(stderr || error.message));
+                const errorMsg = `crytic-compile failed with exit code ${error.code}\nstderr: ${stderr}\nstdout: ${stdout}\nerror: ${error.message}`;
+                reject(new Error(errorMsg));
                 return;
             }
             resolve(stdout || '');
@@ -92,13 +111,22 @@ const formatEchidnaYaml = (config, libraries) => {
     });
     return out;
 };
-const updateEchidnaConfig = async (configPath, libraries) => {
+const updateEchidnaConfig = async (configPath, libraries, verbose = false) => {
+    if (verbose) {
+        console.log(`[VERBOSE] Reading echidna config from: ${configPath}`);
+    }
     const content = await fs.readFile(configPath, 'utf8');
     const parsed = yaml_1.default.parse(content) || {};
     const updated = formatEchidnaYaml(parsed, libraries);
+    if (verbose) {
+        console.log(`[VERBOSE] Updated echidna config:\n${updated}`);
+    }
     await fs.writeFile(configPath, updated, 'utf8');
 };
-const updateMedusaConfig = async (configPath, libraries) => {
+const updateMedusaConfig = async (configPath, libraries, verbose = false) => {
+    if (verbose) {
+        console.log(`[VERBOSE] Reading medusa config from: ${configPath}`);
+    }
     const content = await fs.readFile(configPath, 'utf8');
     const parsed = JSON.parse(content);
     if (!parsed.compilation)
@@ -112,26 +140,50 @@ const updateMedusaConfig = async (configPath, libraries) => {
     else {
         delete parsed.compilation.platformConfig.args;
     }
+    if (verbose) {
+        console.log(`[VERBOSE] Updated medusa config:\n${JSON.stringify(parsed, null, 2)}`);
+    }
     await fs.writeFile(configPath, JSON.stringify(parsed, null, 2), 'utf8');
 };
-async function runLink(foundryRoot, echidnaConfigPath, medusaConfigPath) {
-    const output = await runCryticCompile(foundryRoot);
-    const libraries = parseLibrariesFromOutput(output);
+async function runLink(foundryRoot, echidnaConfigPath, medusaConfigPath, verbose = false) {
+    if (verbose) {
+        console.log(`[VERBOSE] Starting runLink`);
+        console.log(`[VERBOSE] Foundry root: ${foundryRoot}`);
+        console.log(`[VERBOSE] Echidna config path: ${echidnaConfigPath}`);
+        console.log(`[VERBOSE] Medusa config path: ${medusaConfigPath}`);
+    }
+    let output;
+    try {
+        output = await runCryticCompile(foundryRoot, verbose);
+    }
+    catch (e) {
+        throw new Error(`crytic-compile execution failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const libraries = parseLibrariesFromOutput(output, verbose);
     console.log('Detected libraries:', libraries.length ? libraries.join(', ') : '(none)');
     try {
         await fs.access(echidnaConfigPath);
-        await updateEchidnaConfig(echidnaConfigPath, libraries);
+        if (verbose) {
+            console.log(`[VERBOSE] Echidna config exists, updating...`);
+        }
+        await updateEchidnaConfig(echidnaConfigPath, libraries, verbose);
         console.log(`Updated echidna config at ${echidnaConfigPath}`);
     }
     catch (e) {
-        throw new Error(`Failed to update echidna config: ${e}`);
+        throw new Error(`Failed to update echidna config: ${e instanceof Error ? e.message : String(e)}`);
     }
     try {
         await fs.access(medusaConfigPath);
-        await updateMedusaConfig(medusaConfigPath, libraries);
+        if (verbose) {
+            console.log(`[VERBOSE] Medusa config exists, updating...`);
+        }
+        await updateMedusaConfig(medusaConfigPath, libraries, verbose);
         console.log(`Updated medusa config at ${medusaConfigPath}`);
     }
     catch (e) {
-        throw new Error(`Failed to update medusa config: ${e}`);
+        throw new Error(`Failed to update medusa config: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (verbose) {
+        console.log(`[VERBOSE] runLink completed successfully`);
     }
 }

package/dist/processor.js

@@ -107,21 +107,28 @@ const matchesSignature = (sig, allowed) => {
         return true;
     return false;
 };
-const processFunction = (fnDef, includeDeps = false) => {
+const processFunction = (fnDef, includeDeps = false, visited = new Set()) => {
     const result = [];
+    if (visited.has(fnDef.id)) {
+        return result;
+    }
+    visited.add(fnDef.id);
     fnDef.walk((n) => {
         if ('vReferencedDeclaration' in n &&
             n.vReferencedDeclaration &&
             n.vReferencedDeclaration !== fnDef) {
             if (n.vReferencedDeclaration instanceof $.FunctionDefinition ||
                 n.vReferencedDeclaration instanceof $.ModifierDefinition) {
-                const refSourceUnit = n.vReferencedDeclaration.getClosestParentByType($.SourceUnit);
+                if (visited.has(n.vReferencedDeclaration.id)) {
+                    return; // break potential recursion cycles
+                }
                 if (result.some((x) => x.ast === n.vReferencedDeclaration)) {
                     return;
                 }
+                const nextVisited = new Set(visited);
                 result.push({
                     ast: n.vReferencedDeclaration,
-                    children: processFunction(n.vReferencedDeclaration, includeDeps),
+                    children: processFunction(n.vReferencedDeclaration, includeDeps, nextVisited),
                     callType: n instanceof $.FunctionCall ? (0, utils_1.getCallType)(n) : types_1.CallType.Internal,
                 });
             }
@@ -165,14 +172,130 @@ const skipPatterns = [
     'lib/chimera/',
     'lib/setup-helpers/',
 ];
+/**
+ * Normalizes a path by stripping common prefixes like /recon/ that some servers add.
+ * This ensures consistent path handling across different environments.
+ */
+const normalizePath = (relPath) => {
+    // Strip leading /recon/ or recon/ prefix if present
+    let normalized = relPath.replace(/^\/?(recon)\//i, '');
+    // Ensure no leading slash for relative paths
+    normalized = normalized.replace(/^\/+/, '');
+    return normalized;
+};
+/**
+ * Checks if a line should be excluded from coverage.
+ * Lines that Echidna cannot report on:
+ * - Empty lines or whitespace-only lines
+ * - Comment-only lines (// ...) but NOT lines with code before comment
+ * - Lines with only "}"
+ * - Lines with only "});"
+ * - Lines with only "} else {"
+ */
+const isUncoverableLine = (line) => {
+    const trimmed = line.trim();
+    // Empty or whitespace-only
+    if (trimmed === '')
+        return true;
+    // Comment-only line (starts with //)
+    if (/^\/\//.test(trimmed))
+        return true;
+    // Block comment only line
+    if (/^\/\*.*\*\/$/.test(trimmed))
+        return true;
+    if (/^\*/.test(trimmed))
+        return true; // middle of block comment
+    if (/^\/\*/.test(trimmed) && !/\*\//.test(trimmed))
+        return true; // start of multi-line block comment
+    // Lines with only closing braces/brackets
+    if (trimmed === '}')
+        return true;
+    if (trimmed === '});')
+        return true;
+    if (trimmed === ')')
+        return true;
+    if (trimmed === ');')
+        return true;
+    if (trimmed === '_;')
+        return true;
+    if (trimmed === '} else {')
+        return true;
+    if (trimmed === '} else if')
+        return true;
+    if (/^\}\s*else\s*\{$/.test(trimmed))
+        return true;
+    if (/^\}\s*else\s+if\s*\(/.test(trimmed))
+        return true;
+    // Unchecked blocks
+    if (trimmed === 'unchecked {')
+        return true;
+    if (/^unchecked\s*\{$/.test(trimmed))
+        return true;
+    return false;
+};
+/**
+ * Filters a range of lines, removing uncoverable lines and splitting into valid sub-ranges.
+ * @param lines Array of all lines in the file (0-indexed)
+ * @param startLine 1-based start line
+ * @param endLine 1-based end line
+ * @returns Array of range strings (e.g., ["5", "7-9", "12"])
+ */
+const filterLineRange = (lines, startLine, endLine) => {
+    var _a;
+    const result = [];
+    let rangeStart = null;
+    for (let lineNum = startLine; lineNum <= endLine; lineNum++) {
+        const lineIndex = lineNum - 1; // Convert to 0-based index
+        const line = (_a = lines[lineIndex]) !== null && _a !== void 0 ? _a : '';
+        if (isUncoverableLine(line)) {
+            // End current range if we have one
+            if (rangeStart !== null) {
+                const rangeEnd = lineNum - 1;
+                result.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+                rangeStart = null;
+            }
+        }
+        else {
+            // Start new range or continue existing one
+            if (rangeStart === null) {
+                rangeStart = lineNum;
+            }
+        }
+    }
+    // Close any remaining range
+    if (rangeStart !== null) {
+        result.push(rangeStart === endLine ? `${rangeStart}` : `${rangeStart}-${endLine}`);
+    }
+    return result;
+};
 async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
+    var _a;
     const coverage = new Map();
     const fileCache = new Map();
+    const fileLinesCache = new Map();
     let nodesVisited = 0;
     let nodesAdded = 0;
     const shouldSkipPath = (relPath) => {
         return skipPatterns.some((p) => relPath.includes(p));
     };
+    const getFileLines = async (absPath) => {
+        let lines = fileLinesCache.get(absPath);
+        if (!lines) {
+            let content = fileCache.get(absPath);
+            if (!content) {
+                try {
+                    content = await fs.readFile(absPath, 'utf8');
+                    fileCache.set(absPath, content);
+                }
+                catch {
+                    return [];
+                }
+            }
+            lines = content.split('\n');
+            fileLinesCache.set(absPath, lines);
+        }
+        return lines;
+    };
     const addNodeRange = async (node) => {
         var _a;
         nodesVisited++;
@@ -239,14 +362,57 @@ async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
     }
     const normalized = {};
     for (const [relPath, ranges] of coverage.entries()) {
-        if (shouldSkipPath(relPath)) {
+        // Normalize the path to handle /recon/ prefix
+        const normalizedRelPath = normalizePath(relPath);
+        if (shouldSkipPath(normalizedRelPath)) {
             continue; // skip test/script/lib files at the final emission step only
         }
-        const sorted = Array.from(ranges).sort((a, b) => {
-            const start = (val) => parseInt(val.split('-')[0], 10);
-            return start(a) - start(b);
-        });
-        normalized[relPath] = sorted;
+        const absPath = path.isAbsolute(relPath)
+            ? relPath
+            : path.join(foundryRoot, relPath);
+        const lines = await getFileLines(absPath);
+        // Expand all ranges, filter uncoverable lines, and collect valid line numbers
+        const validLines = new Set();
+        for (const range of ranges) {
+            const parts = range.split('-');
+            const start = parseInt(parts[0], 10);
+            const end = parts.length > 1 ? parseInt(parts[1], 10) : start;
+            for (let lineNum = start; lineNum <= end; lineNum++) {
+                const lineIndex = lineNum - 1;
+                const line = (_a = lines[lineIndex]) !== null && _a !== void 0 ? _a : '';
+                if (!isUncoverableLine(line)) {
+                    validLines.add(lineNum);
+                }
+            }
+        }
+        // Convert valid line numbers back to ranges
+        const sortedLines = Array.from(validLines).sort((a, b) => a - b);
+        const filteredRanges = [];
+        let rangeStart = null;
+        let rangeEnd = null;
+        for (const lineNum of sortedLines) {
+            if (rangeStart === null) {
+                rangeStart = lineNum;
+                rangeEnd = lineNum;
+            }
+            else if (lineNum === rangeEnd + 1) {
+                rangeEnd = lineNum;
+            }
+            else {
+                // Emit previous range
+                filteredRanges.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+                rangeStart = lineNum;
+                rangeEnd = lineNum;
+            }
+        }
+        // Emit final range
+        if (rangeStart !== null) {
+            filteredRanges.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+        }
+        if (filteredRanges.length > 0) {
+            // Use normalized path as key for consistent output
+            normalized[normalizedRelPath] = filteredRanges;
+        }
     }
     return normalized;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {