recon-generate 0.0.2

package/README.md

@@ -0,0 +1,84 @@
+## recon-generate
+
+CLI to scaffold the Recon fuzzing suite (Chimera/Echidna/Medusa/Halmos targets) inside a Foundry project.
+
+### Installation
+
+```bash
+npm install -g recon-generate
+# or from this repo
+npm install -g .
+```
+
+For local dev:
+```bash
+npm install
+npm run build
+npm link   # optional, to use globally
+```
+
+### Usage
+
+Run from your Foundry project root (where `foundry.toml` is):
+
+```bash
+recon-generate [options]
+```
+
+Key options:
+
+- `--include "A,B:{foo(uint256)|bar(address)},C"` — include-only these contracts/functions.
+- `--exclude "A:{foo(uint256)},D"` — exclude these contracts/functions.
+- `--admin "A:{fnSig,fnSig}"` — mark listed functions as admin (`asAdmin`).
+- `--mock "A,B"` — generate mocks for the listed contracts (compiled ABIs required); mocks go under `recon[-name]/mocks` and are added to targets.
+- `--name <suite>` — name the suite; affects folder (`recon-<name>`), config filenames (`echidna-<name>.yaml`, `medusa-<name>.json`, `halmos-<name>.toml`), and Crytic tester/runner names.
+- `--force` — replace existing generated suite output under `--output` (does **not** rebuild `.recon/out`).
+- `--force-build` — delete `.recon/out` to force a fresh compile before generation.
+- `--list` — show available contracts/functions after filters, then exit.
+- `--debug` — print filter/matching/debug info.
+- `--recon <path>` — custom recon.json path (defaults to `./recon.json` or `./.recon/recon.json`).
+- `--output <path>` — base path where the suite folder will be placed; we append `/recon` or `/recon-<name>`. Example: `--output test` → `<foundry root>/test/recon-<name>`.
+- `--foundry-config <path>` — path to `foundry.toml` (default `./foundry.toml`).
+
+Examples:
+
+```bash
+# Default scaffolding
+recon-generate
+
+# Exclude a contract
+recon-generate --exclude "Morpho" --force
+
+# Exclude a single function only
+recon-generate --exclude "Morpho:{setOwner(address)}" --force
+
+# Mark specific functions as admin
+recon-generate --admin "Morpho:{setOwner(address),enableIrm(address),setFee(MarketParams,uint256),setFeeRecipient(address)}" --force
+
+# List what would be generated (no files written)
+recon-generate --list --include "Morpho"
+
+# Generate a named suite (outputs under recon-foo, configs echidna-foo.yaml, etc.)
+recon-generate --name foo --force
+
+# Generate mocks and include them in targets
+recon-generate --mock "Morpho,Other" --force
+```
+
+### Behavior
+
+- If the suite output folder exists and `--force` is not provided, the command aborts.
+- `--force` replaces the suite output folder; it does **not** rebuild `.recon/out`.
+- `--force-build` deletes `.recon/out` to force a fresh compile before generation.
+- When `--mock` is used, a fresh build is triggered, mocks are generated under `recon[-name]/mocks`, and a second build picks them up into `.recon/out` and targets.
+- `recon.json` is regenerated every run from current filters/contracts.
+- Include/exclude/admin matching is tolerant of fully qualified struct names vs short names (e.g., `Morpho.MarketParams` vs `MarketParams`).
+- Admin list sets `actor: admin` for matched functions; others default to `actor`.
+
+### Development
+
+```bash
+npm install
+npm run build
+npm link   # to test globally
+```

package/dist/generator.d.ts

@@ -0,0 +1,52 @@
+export type FilterSpec = {
+    contractOnly: Set<string>;
+    functions: Map<string, Set<string>>;
+};
+export interface GeneratorOptions {
+    suiteDir: string;
+    reconConfigPath: string;
+    foundryConfigPath: string;
+    include?: FilterSpec;
+    exclude?: FilterSpec;
+    debug?: boolean;
+    force?: boolean;
+    forceBuild?: boolean;
+    admin?: Map<string, Set<string>>;
+    mocks?: Set<string>;
+    suiteNameSnake: string;
+    suiteNamePascal: string;
+}
+export declare class ReconGenerator {
+    private foundryRoot;
+    private options;
+    private generatedMocks;
+    private allowedMockNames;
+    constructor(foundryRoot: string, options: GeneratorOptions);
+    private logDebug;
+    private outDir;
+    private ensureReconFolder;
+    private removePath;
+    private runCmd;
+    private ensureFoundryConfigExists;
+    private ensureBuild;
+    private installChimera;
+    private installSetupHelpers;
+    private updateRemappings;
+    private updateGitignore;
+    private findSourceContracts;
+    private matchesSignatureOrName;
+    private paramType;
+    private simplifyType;
+    private simplifySignature;
+    private isAdminFunction;
+    private isContractAllowed;
+    private mockNameFor;
+    private findAbiPath;
+    private generateMocks;
+    private copyAndCleanupMocks;
+    private isFunctionIncluded;
+    private buildDefaultReconConfig;
+    private loadReconConfig;
+    run(): Promise<void>;
+    listAvailable(): Promise<void>;
+}

package/dist/generator.js

@@ -0,0 +1,512 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconGenerator = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const abi_to_mock_1 = __importDefault(require("abi-to-mock"));
+const templateManager_1 = require("./templateManager");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class ReconGenerator {
+    constructor(foundryRoot, options) {
+        this.foundryRoot = foundryRoot;
+        this.options = options;
+        this.generatedMocks = new Set();
+        this.allowedMockNames = new Set();
+    }
+    logDebug(message, obj) {
+        if (!this.options.debug)
+            return;
+        if (obj !== undefined) {
+            console.info(`[recon-generate] ${message}`, obj);
+        }
+        else {
+            console.info(`[recon-generate] ${message}`);
+        }
+    }
+    outDir() {
+        return path.join(this.foundryRoot, '.recon', 'out');
+    }
+    async ensureReconFolder() {
+        await fs.mkdir(path.join(this.foundryRoot, '.recon'), { recursive: true });
+    }
+    async removePath(p) {
+        try {
+            await fs.rm(p, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    runCmd(cmd, cwd) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(cmd, { cwd, env: { ...process.env, PATH: (0, utils_1.getEnvPath)() } }, (err, stdout, stderr) => {
+                if (err) {
+                    reject(new Error(stderr || err.message));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async ensureFoundryConfigExists() {
+        if (!(await (0, utils_1.fileExists)(this.options.foundryConfigPath))) {
+            throw new Error(`foundry.toml not found at ${this.options.foundryConfigPath}. Run recon-generate from a Foundry project root or pass --foundry-config <path>.`);
+        }
+    }
+    async ensureBuild() {
+        const outPath = this.outDir();
+        if (await (0, utils_1.fileExists)(outPath)) {
+            return;
+        }
+        await this.ensureReconFolder();
+        const skipArg = '--skip */test/** */tests/** */script/** */scripts/** */contracts/test/**';
+        const cmd = `forge build --build-info ${skipArg} --out .recon/out`.replace(/\s+/g, ' ').trim();
+        await this.runCmd(cmd, this.foundryRoot);
+    }
+    async installChimera() {
+        const chimeraPath = path.join(this.foundryRoot, 'lib', 'chimera');
+        if (await (0, utils_1.fileExists)(chimeraPath)) {
+            return;
+        }
+        await this.runCmd('forge install Recon-Fuzz/chimera --no-git', this.foundryRoot);
+    }
+    async installSetupHelpers() {
+        const setupPath = path.join(this.foundryRoot, 'lib', 'setup-helpers');
+        if (await (0, utils_1.fileExists)(setupPath)) {
+            return;
+        }
+        await this.runCmd('forge install Recon-Fuzz/setup-helpers --no-git', this.foundryRoot);
+    }
+    async updateRemappings() {
+        const remappingsPath = path.join(this.foundryRoot, 'remappings.txt');
+        if (!(await (0, utils_1.fileExists)(remappingsPath))) {
+            await this.runCmd('forge remappings > remappings.txt', this.foundryRoot);
+        }
+        const current = await fs.readFile(remappingsPath, 'utf8');
+        const chimeraMapping = '@chimera/=lib/chimera/src/';
+        const setupToolsMapping = '@recon/=lib/setup-helpers/src/';
+        const remappings = current
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('@chimera') && !line.startsWith('@recon'));
+        remappings.push(chimeraMapping);
+        remappings.push(setupToolsMapping);
+        await fs.writeFile(remappingsPath, remappings.join('\n'));
+    }
+    async updateGitignore() {
+        const gitignorePath = path.join(this.foundryRoot, '.gitignore');
+        const additions = ['crytic-export', 'echidna', 'medusa', '.recon'];
+        let content = '';
+        try {
+            content = await fs.readFile(gitignorePath, 'utf8');
+        }
+        catch {
+            // start empty
+        }
+        let changed = false;
+        for (const line of additions) {
+            if (!content.includes(line)) {
+                content += (content.endsWith('\n') || content.length === 0 ? '' : '\n') + line + '\n';
+                changed = true;
+            }
+        }
+        if (changed) {
+            await fs.writeFile(gitignorePath, content);
+        }
+    }
+    async findSourceContracts() {
+        var _a;
+        const contracts = [];
+        const outDir = this.outDir();
+        try {
+            if (!(await (0, utils_1.fileExists)(outDir))) {
+                throw new Error(`Compiled output not found at ${outDir}. Please ensure forge build runs successfully (we attempt it automatically).`);
+            }
+            const entries = await fs.readdir(outDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const contractDir = path.join(outDir, entry.name);
+                const files = await fs.readdir(contractDir);
+                for (const file of files) {
+                    if (!file.endsWith('.json')) {
+                        continue;
+                    }
+                    const filePath = path.join(contractDir, file);
+                    const content = await fs.readFile(filePath, 'utf8');
+                    const json = JSON.parse(content);
+                    if (json.metadata && json.abi) {
+                        const metadata = json.metadata;
+                        if ((_a = metadata.settings) === null || _a === void 0 ? void 0 : _a.compilationTarget) {
+                            for (const [sourcePath, contractName] of Object.entries(metadata.settings.compilationTarget)) {
+                                const lowerPath = sourcePath.toLowerCase();
+                                const lowerName = String(contractName).toLowerCase();
+                                // Skip interfaces, libraries, and mocks by convention, unless explicitly allowed (generated mocks)
+                                const isGeneratedMock = this.generatedMocks.has(String(contractName));
+                                if (!isGeneratedMock) {
+                                    if (lowerPath.includes('/interface') ||
+                                        lowerPath.includes('/interfaces') ||
+                                        lowerPath.includes('/lib/') ||
+                                        lowerPath.includes('/libraries') ||
+                                        lowerPath.includes('/library') ||
+                                        lowerPath.includes('/mock') ||
+                                        lowerName.includes('mock')) {
+                                        continue;
+                                    }
+                                }
+                                const relativeJson = path.relative(this.foundryRoot, filePath);
+                                let displayedPath = sourcePath;
+                                if (isGeneratedMock) {
+                                    displayedPath = path.relative(this.foundryRoot, path.join(this.options.suiteDir, 'mocks', `${contractName}.sol`));
+                                }
+                                contracts.push({
+                                    path: displayedPath,
+                                    name: contractName,
+                                    jsonPath: relativeJson,
+                                    abi: json.abi,
+                                    enabled: true,
+                                    separated: true,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            this.logDebug('Discovered contracts', contracts.map(c => ({ name: c.name, jsonPath: c.jsonPath, path: c.path })));
+        }
+        catch (e) {
+            throw new Error(`Failed to read compiled contracts at ${outDir}: ${e}`);
+        }
+        return contracts;
+    }
+    matchesSignatureOrName(signature, set) {
+        if (!set || set.size === 0) {
+            return false;
+        }
+        const nameOnly = signature.split('(')[0];
+        const simplifiedSig = this.simplifySignature(signature);
+        const simplifiedName = simplifiedSig.split('(')[0];
+        if (set.has(signature) || set.has(nameOnly) || set.has(simplifiedSig) || set.has(simplifiedName)) {
+            return true;
+        }
+        // Also allow matching on prefix of param types (struct fully qualified vs short)
+        const tryParts = (sig) => {
+            const m = sig.match(/^(.*?)\((.*)\)$/);
+            if (!m) {
+                return [];
+            }
+            const name = m[1];
+            const params = m[2];
+            const parts = params ? params.split(',').map(p => p.trim()) : [];
+            const shortened = parts.map(p => this.simplifyType(p));
+            return [`${name}(${shortened.join(',')})`, name];
+        };
+        for (const candidate of tryParts(signature).concat(tryParts(simplifiedSig))) {
+            if (set.has(candidate)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    paramType(p) {
+        if (p.internalType) {
+            const parts = p.internalType.trim().split(/\s+/);
+            if (parts.length > 1) {
+                return parts[1];
+            }
+            return parts[0];
+        }
+        return p.type;
+    }
+    simplifyType(t) {
+        const arraySuffixMatch = t.match(/(\[.*\])$/);
+        const arraySuffix = arraySuffixMatch ? arraySuffixMatch[1] : '';
+        const base = arraySuffix ? t.slice(0, -arraySuffix.length) : t;
+        const segments = base.split('.');
+        const simple = segments[segments.length - 1];
+        return `${simple}${arraySuffix}`;
+    }
+    simplifySignature(signature) {
+        const match = signature.match(/^(.*?)\((.*)\)$/);
+        if (!match) {
+            return signature;
+        }
+        const name = match[1];
+        const params = match[2];
+        if (!params) {
+            return `${name}()`;
+        }
+        const simplifiedParams = params.split(',').map(p => this.simplifyType(p.trim())).join(',');
+        return `${name}(${simplifiedParams})`;
+    }
+    isAdminFunction(contractName, signature) {
+        if (!this.options.admin || this.options.admin.size === 0) {
+            return false;
+        }
+        const set = this.options.admin.get(contractName);
+        if (!set) {
+            return false;
+        }
+        const matched = this.matchesSignatureOrName(signature, set);
+        if (matched && this.options.debug) {
+            this.logDebug('Matched admin function', { contractName, signature, set: Array.from(set) });
+        }
+        return matched;
+    }
+    isContractAllowed(name) {
+        const { include, exclude } = this.options;
+        if (this.options.mocks && this.options.mocks.has(name)) {
+            this.logDebug(`Contract filtered because it is mocked`, { name });
+            return false;
+        }
+        // Include logic
+        if (include && (include.contractOnly.size > 0 || include.functions.size > 0)) {
+            const inInclude = include.contractOnly.has(name) || include.functions.has(name);
+            if (!inInclude) {
+                this.logDebug(`Contract filtered by include`, { name });
+                return false;
+            }
+        }
+        // Exclude logic
+        if (exclude && exclude.contractOnly.has(name)) {
+            this.logDebug(`Contract filtered by exclude`, { name });
+            return false;
+        }
+        return true;
+    }
+    mockNameFor(contract) {
+        return `${contract}Mock`;
+    }
+    async findAbiPath(contractName) {
+        const outDir = this.outDir();
+        const entries = await fs.readdir(outDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const candidate = path.join(outDir, entry.name, `${contractName}.json`);
+            if (await (0, utils_1.fileExists)(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error(`ABI for contract ${contractName} not found in .recon/out. Build may have failed.`);
+    }
+    async generateMocks() {
+        if (!this.options.mocks || this.options.mocks.size === 0) {
+            return null;
+        }
+        const tempSrc = path.join(this.foundryRoot, 'src', '__recon');
+        await fs.mkdir(tempSrc, { recursive: true });
+        for (const name of this.options.mocks) {
+            const mockName = this.mockNameFor(name);
+            const abiPath = await this.findAbiPath(name);
+            await (0, abi_to_mock_1.default)(abiPath, tempSrc, mockName);
+            this.generatedMocks.add(mockName);
+            this.allowedMockNames.add(mockName);
+            this.logDebug('Generated mock', { name, mockName, abiPath, output: tempSrc });
+        }
+        return tempSrc;
+    }
+    async copyAndCleanupMocks(tempSrc) {
+        if (!tempSrc) {
+            return;
+        }
+        const mocksDir = path.join(this.options.suiteDir, 'mocks');
+        await fs.mkdir(mocksDir, { recursive: true });
+        const tempFiles = await fs.readdir(tempSrc);
+        for (const f of tempFiles) {
+            if (!f.endsWith('.sol')) {
+                continue;
+            }
+            const srcPath = path.join(tempSrc, f);
+            const destPath = path.join(mocksDir, f);
+            await fs.copyFile(srcPath, destPath);
+        }
+        await this.removePath(tempSrc);
+    }
+    isFunctionIncluded(contractName, signature) {
+        const { include, exclude } = this.options;
+        // Include functions filter (if provided for this contract)
+        if (include && include.functions.size > 0) {
+            const fnSet = include.functions.get(contractName);
+            if (fnSet) {
+                if (!this.matchesSignatureOrName(signature, fnSet)) {
+                    this.logDebug('Function filtered by include', { contractName, signature });
+                    return false;
+                }
+            }
+        }
+        // Exclude functions filter
+        if (exclude && exclude.functions.size > 0) {
+            const fnSet = exclude.functions.get(contractName);
+            if (fnSet && this.matchesSignatureOrName(signature, fnSet)) {
+                this.logDebug('Function filtered by exclude', { contractName, signature });
+                return false;
+            }
+        }
+        return true;
+    }
+    async buildDefaultReconConfig(contracts) {
+        var _a;
+        const config = {};
+        for (const contract of contracts) {
+            if (!this.isContractAllowed(contract.name)) {
+                continue;
+            }
+            const funcs = [];
+            for (const item of contract.abi) {
+                if (item.type === 'function' && !((_a = item.stateMutability) === null || _a === void 0 ? void 0 : _a.match(/^(view|pure)$/))) {
+                    const signature = `${item.name}(${item.inputs.map((i) => this.paramType(i)).join(',')})`;
+                    if (this.isFunctionIncluded(contract.name, signature)) {
+                        const actor = this.isAdminFunction(contract.name, signature) ? types_1.Actor.ADMIN : types_1.Actor.ACTOR;
+                        if (this.options.debug && actor === types_1.Actor.ADMIN) {
+                            this.logDebug('Assigning admin actor in default config', { contract: contract.name, signature });
+                        }
+                        funcs.push({ signature, actor, mode: types_1.Mode.NORMAL });
+                    }
+                }
+            }
+            if (funcs.length === 0) {
+                continue;
+            }
+            config[contract.jsonPath] = {
+                enabled: true,
+                functions: funcs,
+                separated: true,
+            };
+            this.logDebug('Added contract to recon config (default)', { contract: contract.name, functions: funcs.map(f => f.signature) });
+        }
+        return config;
+    }
+    async loadReconConfig(contracts) {
+        const reconPath = this.options.reconConfigPath;
+        const config = await this.buildDefaultReconConfig(contracts);
+        await fs.mkdir(path.dirname(reconPath), { recursive: true });
+        await fs.writeFile(reconPath, JSON.stringify(config, null, 2));
+        this.logDebug('Wrote new recon config', config);
+        return config;
+    }
+    async run() {
+        var _a;
+        await this.ensureFoundryConfigExists();
+        const outPath = this.outDir();
+        const mockTargets = (_a = this.options.mocks) !== null && _a !== void 0 ? _a : new Set();
+        this.generatedMocks.clear();
+        this.allowedMockNames = new Set([...mockTargets].map(n => this.mockNameFor(n)));
+        const suiteExists = await (0, utils_1.fileExists)(this.options.suiteDir);
+        if (suiteExists) {
+            if (!this.options.force) {
+                throw new Error(`${this.options.suiteDir} already exists. Re-run with --force to replace generated suite (use --force-build to rebuild .recon/out).`);
+            }
+            this.logDebug('Force enabled: removing existing generated output');
+            await this.removePath(this.options.suiteDir);
+        }
+        if (this.options.forceBuild || mockTargets.size > 0 || !(await (0, utils_1.fileExists)(outPath))) {
+            if (await (0, utils_1.fileExists)(outPath)) {
+                this.logDebug('Rebuilding: removing existing .recon/out');
+                await this.removePath(outPath);
+            }
+            await this.ensureBuild(); // first build to get ABIs
+        }
+        // Generate mocks if requested, then rebuild to pick them up
+        let tempMockSrc = null;
+        if (mockTargets.size > 0) {
+            tempMockSrc = await this.generateMocks();
+            if (await (0, utils_1.fileExists)(outPath)) {
+                await this.removePath(outPath);
+            }
+            await this.ensureBuild();
+        }
+        await this.installChimera();
+        await this.installSetupHelpers();
+        await this.updateRemappings();
+        await this.updateGitignore();
+        // After all builds, copy mocks to suite folder and clean temp
+        if (mockTargets.size > 0) {
+            await this.copyAndCleanupMocks(tempMockSrc);
+        }
+        const contracts = await this.findSourceContracts();
+        const filteredContracts = contracts.filter(c => this.isContractAllowed(c.name));
+        if (filteredContracts.length === 0) {
+            this.logDebug('No contracts left after include/exclude filters');
+        }
+        const reconConfig = await this.loadReconConfig(filteredContracts);
+        const tm = new templateManager_1.TemplateManager(this.foundryRoot, this.options.suiteDir, this.options.suiteNameSnake, this.options.suiteNamePascal);
+        await tm.generateTemplates(filteredContracts, reconConfig);
+    }
+    async listAvailable() {
+        var _a;
+        await this.ensureFoundryConfigExists();
+        await this.ensureBuild();
+        const contracts = await this.findSourceContracts();
+        const filtered = [];
+        for (const contract of contracts) {
+            if (!this.isContractAllowed(contract.name)) {
+                continue;
+            }
+            const fns = [];
+            for (const item of contract.abi) {
+                if (item.type === 'function' && !((_a = item.stateMutability) === null || _a === void 0 ? void 0 : _a.match(/^(view|pure)$/))) {
+                    const signature = `${item.name}(${item.inputs.map((i) => this.paramType(i)).join(',')})`;
+                    if (this.isFunctionIncluded(contract.name, signature)) {
+                        fns.push(signature);
+                    }
+                }
+            }
+            if (fns.length > 0) {
+                filtered.push({ name: contract.name, path: contract.path, functions: fns });
+            }
+        }
+        console.log('Available contracts and functions (after filters):');
+        for (const c of filtered) {
+            console.log(`- ${c.name} :: ${c.path}`);
+            for (const fn of c.functions) {
+                console.log(`    • ${fn}`);
+            }
+        }
+        if (filtered.length === 0) {
+            console.log('No contracts/functions match the current include/exclude filters.');
+        }
+    }
+}
+exports.ReconGenerator = ReconGenerator;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};