recon-generate 0.0.9 → 0.0.11

package/dist/generator.d.ts

@@ -24,6 +24,7 @@ export declare class ReconGenerator {
     private generatedMocks;
     private allowedMockNames;
     private contractKindCache;
+    private abstractContractCache;
     constructor(foundryRoot: string, options: GeneratorOptions);
     private logDebug;
     private outDir;
@@ -37,6 +38,7 @@ export declare class ReconGenerator {
     private updateRemappings;
     private updateGitignore;
     private getContractKind;
+    private isAbstractContract;
     private findSourceContracts;
     private matchesSignatureOrName;
     private paramType;

package/dist/generator.js

@@ -54,6 +54,7 @@ class ReconGenerator {
         this.generatedMocks = new Set();
         this.allowedMockNames = new Set();
         this.contractKindCache = new Map();
+        this.abstractContractCache = new Map();
     }
     logDebug(message, obj) {
         if (!this.options.debug)
@@ -196,6 +197,53 @@ class ReconGenerator {
         this.contractKindCache.set(absPath, fileCache);
         return kind;
     }
+    async isAbstractContract(sourcePath, contractName) {
+        const absPath = path.isAbsolute(sourcePath) ? sourcePath : path.join(this.foundryRoot, sourcePath);
+        let fileCache = this.abstractContractCache.get(absPath);
+        if (fileCache && fileCache.has(contractName)) {
+            return fileCache.get(contractName);
+        }
+        let content;
+        try {
+            content = await fs.readFile(absPath, 'utf8');
+        }
+        catch (e) {
+            this.logDebug('Failed to read source when determining abstract contract', { sourcePath, error: String(e) });
+            return false;
+        }
+        let ast;
+        try {
+            ast = parser_1.default.parse(content, { tolerant: true });
+        }
+        catch (e) {
+            this.logDebug('Failed to parse source when determining abstract contract', { sourcePath, error: String(e) });
+            ast = null;
+        }
+        fileCache = fileCache !== null && fileCache !== void 0 ? fileCache : new Map();
+        let isAbstract = false;
+        const children = ast === null || ast === void 0 ? void 0 : ast.children;
+        if (Array.isArray(children)) {
+            for (const node of children) {
+                if ((node === null || node === void 0 ? void 0 : node.type) === 'ContractDefinition' && node.name === contractName) {
+                    if (node.abstract === true) {
+                        isAbstract = true;
+                    }
+                    break;
+                }
+            }
+        }
+        if (!isAbstract) {
+            // Fallback: text search for `abstract contract <Name>` to cover parser misses
+            const stripped = content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+            const pattern = new RegExp(`\\babstract\\s+contract\\s+${contractName}\\b`);
+            if (pattern.test(stripped)) {
+                isAbstract = true;
+            }
+        }
+        fileCache.set(contractName, isAbstract);
+        this.abstractContractCache.set(absPath, fileCache);
+        return isAbstract;
+    }
     async findSourceContracts() {
         var _a, _b;
         const contracts = [];
@@ -226,11 +274,34 @@ class ReconGenerator {
                                 const lowerName = String(contractName).toLowerCase();
                                 const isGeneratedMock = this.generatedMocks.has(String(contractName));
                                 const contractKind = await this.getContractKind(sourcePath, String(contractName));
+                                const isAbstract = await this.isAbstractContract(sourcePath, String(contractName));
+                                const absSourcePath = path.isAbsolute(sourcePath)
+                                    ? sourcePath
+                                    : path.join(this.foundryRoot, sourcePath);
+                                const relSourcePath = path.relative(this.foundryRoot, absSourcePath).replace(/\\/g, '/').toLowerCase();
+                                const skipPrefixes = [
+                                    'test/',
+                                    'tests/',
+                                    'script/',
+                                    'scripts/',
+                                    'contracts/test/',
+                                    'contracts/tests/',
+                                    'lib/',
+                                ];
                                 // Check if contract is explicitly included or mocked - if so, don't filter by kind
                                 const isExplicitlyIncluded = this.options.include &&
                                     (this.options.include.contractOnly.has(String(contractName)) ||
                                         this.options.include.functions.has(String(contractName)));
                                 const isExplicitlyMocked = (_b = this.options.mocks) === null || _b === void 0 ? void 0 : _b.has(String(contractName));
+                                const inSkipDir = skipPrefixes.some(prefix => relSourcePath.startsWith(prefix));
+                                if (!isGeneratedMock && inSkipDir && !isExplicitlyIncluded && !isExplicitlyMocked) {
+                                    this.logDebug('Skipping artifact from non-source directory', { contractName, sourcePath });
+                                    continue;
+                                }
+                                if (isAbstract && !isExplicitlyIncluded && !isExplicitlyMocked) {
+                                    this.logDebug('Skipping abstract contract', { contractName, sourcePath });
+                                    continue;
+                                }
                                 if ((contractKind === 'interface' || contractKind === 'library') && !isExplicitlyIncluded && !isExplicitlyMocked) {
                                     this.logDebug('Skipping non-contract artifact', { contractName, sourcePath, contractKind });
                                     continue;

package/dist/index.js

@@ -38,6 +38,7 @@ const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const case_1 = require("case");
 const generator_1 = require("./generator");
+const wakeGenerator_1 = require("./wakeGenerator");
 const coverage_1 = require("./coverage");
 const pathsGenerator_1 = require("./pathsGenerator");
 const utils_1 = require("./utils");
@@ -146,6 +147,8 @@ async function main() {
         .option('--crytic-name <name>', 'Name of the Crytic tester contract to compile', 'CryticTester')
         .option('--name <suite>', 'Suite name; affects paths filename (recon-<name>-paths.json)')
         .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
+        .option('--dry-run', 'Do not enumerate paths; only report which functions/external calls would be processed')
+        .option('--max-paths <n>', 'Cap path enumeration per function to avoid OOM (default: 5000)')
         .action(async (opts, cmd) => {
         var _a;
         const workspaceRoot = process.cwd();
@@ -154,7 +157,11 @@ async function main() {
         const parentOpts = ((_a = cmd.parent) === null || _a === void 0 ? void 0 : _a.opts()) || {};
         const suiteRaw = opts.name || parentOpts.name ? String(opts.name || parentOpts.name).trim() : '';
         const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
-        await (0, pathsGenerator_1.runPaths)(foundryRoot, opts.cryticName || 'CryticTester', suiteSnake);
+        const maxPaths = opts.maxPaths ? parseInt(String(opts.maxPaths), 10) : 5000;
+        await (0, pathsGenerator_1.runPaths)(foundryRoot, opts.cryticName || 'CryticTester', suiteSnake, {
+            dryRun: !!opts.dryRun,
+            maxPaths: Number.isFinite(maxPaths) && maxPaths > 0 ? maxPaths : undefined,
+        });
     });
     program
         .command('link')
@@ -185,6 +192,53 @@ async function main() {
             : path.join(foundryRoot, medusaConfigOpt);
         await (0, link_1.runLink)(foundryRoot, echidnaConfigPath, medusaConfigPath, !!opts.verbose);
     });
+    program
+        .command('wake')
+        .description('Generate Python fuzzing suite using Wake framework')
+        .option('--include <spec>', 'Include filter: e.g. "A,B:{foo(uint256)|bar(address)},C"')
+        .option('--exclude <spec>', 'Exclude filter: e.g. "A:{foo(uint256)},D" or just "B"')
+        .option('--admin <spec>', 'Mark functions as admin: e.g. "A:{foo(uint256),bar()},B:{baz(address)}"')
+        .option('--name <suite>', 'Suite name; affects folder (tests/recon-name)')
+        .option('-o, --output <path>', 'Custom output folder for tests')
+        .option('--debug', 'Print debug info about filters and selection')
+        .option('--list', 'List available contracts/functions (after filters) and exit')
+        .option('--force', 'Replace existing generated suite output')
+        .option('--force-build', 'Delete .recon/out to force a fresh forge build before generating')
+        .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
+        .action(async (opts, cmd) => {
+        var _a;
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        const parentOpts = ((_a = cmd.parent) === null || _a === void 0 ? void 0 : _a.opts()) || {};
+        const includeFilter = parseFilter(opts.include);
+        const excludeFilter = parseFilter(opts.exclude);
+        const adminFilter = parseFilter(opts.admin);
+        const suiteRaw = opts.name || parentOpts.name ? String(opts.name || parentOpts.name).trim() : '';
+        const suiteSnake = suiteRaw ? (0, case_1.snake)(suiteRaw) : '';
+        const suitePascal = suiteRaw ? (0, case_1.pascal)(suiteRaw) : '';
+        const suiteFolderName = suiteSnake ? `recon_${suiteSnake}` : 'recon';
+        const baseOut = opts.output ? String(opts.output) : 'tests';
+        const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.resolve(foundryRoot, baseOut);
+        const suiteDir = path.resolve(baseOutPath, suiteFolderName);
+        const generator = new wakeGenerator_1.WakeGenerator(foundryRoot, {
+            suiteDir,
+            foundryConfigPath: foundryConfig,
+            include: includeFilter,
+            exclude: excludeFilter,
+            admin: adminFilter ? adminFilter.functions : undefined,
+            debug: !!opts.debug || !!parentOpts.debug,
+            force: Boolean(opts.force || parentOpts.force),
+            forceBuild: !!opts.forceBuild || !!parentOpts.forceBuild,
+            suiteNameSnake: suiteSnake,
+            suiteNamePascal: suitePascal,
+        });
+        if (opts.list) {
+            await generator.listAvailable();
+            return;
+        }
+        await generator.run();
+    });
     program
         .action(async (opts) => {
         const workspaceRoot = process.cwd();

package/dist/pathsGenerator.d.ts

@@ -4,6 +4,10 @@
  * Generates minimal paths needed for 100% branch coverage.
  * Output is optimized for LLM consumption.
  */
+export interface RunPathsOptions {
+    dryRun?: boolean;
+    maxPaths?: number;
+}
 /** Simple output: function name -> array of path condition strings */
 export type PathOutput = Record<string, string[]>;
-export declare const runPaths: (foundryRoot: string, cryticName: string, suiteNameSnake?: string) => Promise<void>;
+export declare const runPaths: (foundryRoot: string, cryticName: string, suiteNameSnake?: string, options?: RunPathsOptions) => Promise<void>;

package/dist/pathsGenerator.js

@@ -103,7 +103,7 @@ const loadLatestSourceUnits = async (foundryRoot) => {
     return reader.read(filteredAstData);
 };
 // ==================== Main Entry ====================
-const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
+const runPaths = async (foundryRoot, cryticName, suiteNameSnake, options = {}) => {
     const buildCmd = `forge build --contracts ${cryticName} --build-info --out .recon/out`.replace(/\s+/g, ' ').trim();
     await runCmd(buildCmd, foundryRoot);
     const sourceUnits = await loadLatestSourceUnits(foundryRoot);
@@ -123,6 +123,18 @@ const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
     // Process each function
     const output = {};
     let totalPaths = 0;
+    if (options.dryRun) {
+        console.log(`[dry-run] Crytic contract: ${cryticName}`);
+        console.log(`[dry-run] Target functions (${targetFunctions.length}):`);
+        for (const func of targetFunctions) {
+            const externalCall = findExternalCall(func);
+            const extLabel = externalCall ? `${externalCall.contract}.${externalCall.function}` : 'none';
+            console.log(`  - ${func.name} -> external call: ${extLabel}`);
+        }
+        console.log('[dry-run] Skipping path enumeration.');
+        return;
+    }
+    const maxPaths = options.maxPaths && options.maxPaths > 0 ? options.maxPaths : undefined;
     for (const func of targetFunctions) {
         // Find external call
         const externalCall = findExternalCall(func);
@@ -145,8 +157,8 @@ const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
         const callTree = (0, call_tree_builder_1.buildCallTree)(extFunc, [], undefined, undefined, context);
         // Build param mapping
         const paramMapping = buildParamMapping(func, externalCall);
-        // Enumerate paths
-        const enumerator = new PathEnumerator(sourceUnits, paramMapping);
+        // Enumerate paths with optional cap
+        const enumerator = new PathEnumerator(sourceUnits, paramMapping, maxPaths);
         const paths = enumerator.enumerate(callTree);
         if (paths.length === 0)
             continue;
@@ -157,11 +169,14 @@ const runPaths = async (foundryRoot, cryticName, suiteNameSnake) => {
             continue;
         output[func.name] = simplified;
         totalPaths += simplified.length;
+        if (enumerator.wasTruncated()) {
+            console.warn(`[recon-generate] Warning: Path enumeration for ${func.name} reached the max limit${maxPaths ? ` (${maxPaths})` : ''} and was truncated.`);
+        }
     }
     const pathsName = suiteNameSnake ? `recon-${suiteNameSnake}-paths.json` : 'recon-paths.json';
     const pathsFilePath = path.join(foundryRoot, pathsName);
     await fs.writeFile(pathsFilePath, JSON.stringify(output, null, 2));
-    console.log(`[recon-generate] Wrote paths file to ${pathsFilePath}`);
+    console.log(`[recon-generate] Wrote paths file to ${pathsFilePath} (total paths: ${totalPaths})`);
 };
 exports.runPaths = runPaths;
 // ==================== Source Helpers ====================
@@ -224,20 +239,26 @@ function buildParamMapping(func, extCall) {
 }
 // ==================== Path Enumeration ====================
 class PathEnumerator {
-    constructor(sourceUnits, paramMap) {
+    constructor(sourceUnits, paramMap, maxPaths) {
         this.pathIdCounter = 0;
         this.branchPoints = 0;
+        this.truncated = false;
         this.sourceUnits = sourceUnits;
         this.paramMap = new Map(paramMap);
+        this.maxPaths = maxPaths;
     }
     enumerate(callTree) {
         this.pathIdCounter = 0;
         this.branchPoints = 0;
+        this.truncated = false;
         const paths = this.processCallTree(callTree);
         return paths
             .filter(p => p.result === 'success')
             .map(p => ({ id: p.id, conditions: p.conditions, requires: p.requires, result: p.result }));
     }
+    wasTruncated() {
+        return this.truncated;
+    }
     processCallTree(node) {
         const def = node.definition;
         // Process children first (leaf to root)
@@ -252,8 +273,13 @@ class PathEnumerator {
             this.paramMap = savedMap;
         }
         // Process function body
+        const firstId = ++this.pathIdCounter;
+        if (this.maxPaths && firstId > this.maxPaths) {
+            this.truncated = true;
+            return [];
+        }
         let activePaths = [{
-                id: ++this.pathIdCounter,
+                id: firstId,
                 conditions: [],
                 requires: [],
                 terminated: false
@@ -336,8 +362,13 @@ class PathEnumerator {
             for (const clause of stmt.vClauses) {
                 if (clause.errorName === '') {
                     // Success clause (try block) - external call succeeds
+                    const nextId = ++this.pathIdCounter;
+                    if (this.maxPaths && nextId > this.maxPaths) {
+                        this.truncated = true;
+                        continue;
+                    }
                     const successPath = {
-                        id: ++this.pathIdCounter,
+                        id: nextId,
                         conditions: [...path.conditions, {
                                 original: callExpr,
                                 resolved: callExpr,
@@ -351,8 +382,13 @@ class PathEnumerator {
                 }
                 else {
                     // Catch clause - external call fails
+                    const nextCatchId = ++this.pathIdCounter;
+                    if (this.maxPaths && nextCatchId > this.maxPaths) {
+                        this.truncated = true;
+                        continue;
+                    }
                     const catchPath = {
-                        id: ++this.pathIdCounter,
+                        id: nextCatchId,
                         conditions: [...path.conditions, {
                                 original: callExpr,
                                 resolved: callExpr,
@@ -411,8 +447,13 @@ class PathEnumerator {
                 continue;
             }
             // True branch
+            const nextIdTrue = ++this.pathIdCounter;
+            if (this.maxPaths && nextIdTrue > this.maxPaths) {
+                this.truncated = true;
+                break;
+            }
             const truePath = {
-                id: ++this.pathIdCounter,
+                id: nextIdTrue,
                 conditions: [...path.conditions, { original: condOrig, resolved: condResolved, mustBeTrue: true }],
                 requires: [...path.requires],
                 terminated: false
@@ -427,8 +468,13 @@ class PathEnumerator {
                 results.push(truePath);
             }
             // False branch
+            const nextIdFalse = ++this.pathIdCounter;
+            if (this.maxPaths && nextIdFalse > this.maxPaths) {
+                this.truncated = true;
+                break;
+            }
             const falsePath = {
-                id: ++this.pathIdCounter,
+                id: nextIdFalse,
                 conditions: [...path.conditions, { original: condOrig, resolved: condResolved, mustBeTrue: false }],
                 requires: [...path.requires],
                 terminated: false
@@ -483,8 +529,13 @@ class PathEnumerator {
                         for (const cp of cPaths) {
                             if (cp.result === 'revert')
                                 continue;
+                            const nextId = ++this.pathIdCounter;
+                            if (this.maxPaths && nextId > this.maxPaths) {
+                                this.truncated = true;
+                                continue;
+                            }
                             merged.push({
-                                id: ++this.pathIdCounter,
+                                id: nextId,
                                 conditions: [...p.conditions, ...cp.conditions],
                                 requires: [...p.requires, ...cp.requires],
                                 terminated: false

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/dist/templates/setup.js

@@ -27,11 +27,12 @@ import "{{this.path}}";
 {{/each}}
 
 abstract contract Setup is BaseSetup, ActorManager, AssetManager, Utils {
-    {{#each contracts}}
+{{#each contracts}}
     {{this.name}} {{camel this.name}};
-    {{#if this.isDynamic}}address[] {{camel this.name}}_s;
+    {{#if this.isDynamic}}
+    address[] {{camel this.name}}_s;
     {{/if}}
-    {{/each}}
+{{/each}}
     
     /// === Setup === ///
     /// This contains all calls to be performed in the tester constructor, both for Echidna and Foundry

package/dist/templates/wake/before_after.d.ts

@@ -0,0 +1 @@
+export declare const beforeAfterTemplate: HandlebarsTemplateDelegate<any>;

package/dist/templates/wake/before_after.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeAfterTemplate = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+exports.beforeAfterTemplate = handlebars_1.default.compile(`
+from wake.testing import *
+from wake.testing.fuzzing import *
+from .setup import Setup
+from dataclasses import dataclass
+
+@dataclass
+class Vars:
+    # Example ghost variables for tracking state
+    # total_assets: int = 0
+    pass
+
+class BeforeAfter(Setup):
+    _before: Vars
+    _after: Vars
+
+    def pre_flow(self, flow: Callable) -> None:
+        # Called before each flow
+        # self._before = Vars(total_assets=self.complexVault.totalAssets())
+        pass
+
+    def post_flow(self, flow: Callable) -> None:
+        # Called after each flow
+        # self._after = Vars(total_assets=self.complexVault.totalAssets())
+        pass
+`, { noEscape: true });

package/dist/templates/wake/conftest.d.ts

@@ -0,0 +1 @@
+export declare const conftestTemplate: HandlebarsTemplateDelegate<any>;