recon-generate 0.0.31 → 0.0.33

package/dist/generator.d.ts

@@ -1,3 +1,4 @@
+import { FoundryConfig } from './types';
 export type FilterSpec = {
     contractOnly: Set<string>;
     functions: Map<string, Set<string>>;
@@ -18,6 +19,7 @@ export interface GeneratorOptions {
     suiteNamePascal: string;
     coverage?: boolean;
     params?: boolean;
+    foundryConfig?: FoundryConfig;
 }
 export declare class ReconGenerator {
     private foundryRoot;
@@ -26,7 +28,9 @@ export declare class ReconGenerator {
     private allowedMockNames;
     private contractKindCache;
     private abstractContractCache;
+    private _foundryConfig?;
     constructor(foundryRoot: string, options: GeneratorOptions);
+    private getConfig;
     private logDebug;
     private outDir;
     private ensureReconFolder;

package/dist/generator.js

@@ -55,6 +55,16 @@ class ReconGenerator {
         this.allowedMockNames = new Set();
         this.contractKindCache = new Map();
         this.abstractContractCache = new Map();
+        if (options.foundryConfig) {
+            this._foundryConfig = options.foundryConfig;
+        }
+    }
+    async getConfig() {
+        if (!this._foundryConfig) {
+            this._foundryConfig = await (0, utils_1.getFoundryConfig)(this.foundryRoot);
+            this.logDebug('Resolved foundry config', this._foundryConfig);
+        }
+        return this._foundryConfig;
     }
     logDebug(message, obj) {
         if (!this.options.debug)
@@ -103,7 +113,10 @@ class ReconGenerator {
             return;
         }
         await this.ensureReconFolder();
-        const skipArg = '--skip */test/** */tests/** */script/** */scripts/** */contracts/test/**';
+        const config = await this.getConfig();
+        const skipDirs = new Set([config.test, config.script]);
+        const skipGlobs = Array.from(skipDirs).map(d => `*/${d}/**`);
+        const skipArg = skipGlobs.length > 0 ? `--skip ${skipGlobs.join(' ')}` : '';
         const cmd = `forge build --build-info ${skipArg} --out .recon/out`.replace(/\s+/g, ' ').trim();
         await this.runCmd(cmd, this.foundryRoot);
     }
@@ -122,6 +135,14 @@ class ReconGenerator {
         await this.runCmd('forge install Recon-Fuzz/setup-helpers', this.foundryRoot);
     }
     async updateRemappings() {
+        const config = await this.getConfig();
+        // If foundry config already has @chimera and @recon remappings, skip file manipulation
+        const hasChimera = config.remappings.some(r => r.startsWith('@chimera'));
+        const hasRecon = config.remappings.some(r => r.startsWith('@recon'));
+        if (hasChimera && hasRecon) {
+            this.logDebug('Remappings for @chimera and @recon already present in foundry config, skipping remappings.txt update');
+            return;
+        }
         const remappingsPath = path.join(this.foundryRoot, 'remappings.txt');
         if (!(await (0, utils_1.fileExists)(remappingsPath))) {
             await this.runCmd('forge remappings > remappings.txt', this.foundryRoot);
@@ -133,8 +154,10 @@ class ReconGenerator {
             .split('\n')
             .map(line => line.trim())
             .filter(line => line && !line.startsWith('@chimera') && !line.startsWith('@recon'));
-        remappings.push(chimeraMapping);
-        remappings.push(setupToolsMapping);
+        if (!hasChimera)
+            remappings.push(chimeraMapping);
+        if (!hasRecon)
+            remappings.push(setupToolsMapping);
         await fs.writeFile(remappingsPath, remappings.join('\n'));
     }
     async updateGitignore() {
@@ -248,6 +271,7 @@ class ReconGenerator {
         var _a, _b;
         const contracts = [];
         const outDir = this.outDir();
+        const config = await this.getConfig();
         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).`);
@@ -280,13 +304,11 @@ class ReconGenerator {
                                     : 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/',
+                                    ...new Set([
+                                        `${config.test}/`,
+                                        `${config.script}/`,
+                                        ...config.libs.map(l => `${l}/`),
+                                    ]),
                                 ];
                                 // Check if contract is explicitly included or mocked - if so, don't filter by kind
                                 const isExplicitlyIncluded = this.options.include &&
@@ -450,7 +472,8 @@ class ReconGenerator {
         if (!this.options.mocks || this.options.mocks.size === 0) {
             return null;
         }
-        const tempSrc = path.join(this.foundryRoot, 'src', '__recon');
+        const config = await this.getConfig();
+        const tempSrc = path.join(this.foundryRoot, config.src, '__recon');
         await fs.mkdir(tempSrc, { recursive: true });
         for (const name of this.options.mocks) {
             const mockName = this.mockNameFor(name);
@@ -566,22 +589,21 @@ class ReconGenerator {
             }
             await this.ensureBuild(); // first build to get ABIs
         }
+        const config = await this.getConfig();
         let sourceUnits = [];
+        let symbolsInfo = { byFile: new Map(), definedIn: new Map() };
         try {
-            // Paths to skip - test and script directories
             const skipPatterns = [
-                'test/',
-                'tests/',
-                'script/',
-                'scripts/',
-                'contracts/test/',
-                'contracts/script/',
-                'contracts/scripts/',
-                'forge-std/'
+                `${config.test}/`,
+                `${config.script}/`,
+                ...config.libs.map(l => `${l}/`),
+                'forge-std/',
             ];
             const result = await (0, utils_1.loadLatestBuildInfo)(this.foundryRoot, '.recon/out', skipPatterns);
             sourceUnits = result.sourceUnits;
+            symbolsInfo = (0, utils_1.buildExportedSymbolsMap)(result.buildOutput);
             this.logDebug('Loaded source units', { count: sourceUnits.length });
+            this.logDebug('Built symbol maps', { files: symbolsInfo.byFile.size, symbols: symbolsInfo.definedIn.size });
         }
         catch (e) {
             this.logDebug('Failed to load build info', { error: String(e) });
@@ -676,7 +698,7 @@ class ReconGenerator {
             }
         }
         const tm = new templateManager_1.TemplateManager(this.foundryRoot, this.options.suiteDir, this.options.suiteNameSnake, this.options.suiteNamePascal, (_c = this.options.dynamicDeploy) !== null && _c !== void 0 ? _c : new Set());
-        await tm.generateTemplates(collected.enabledContracts, collected.adminFunctions, collected.nonSeparatedFunctions, collected.separatedByContract, collected.allContractNames);
+        await tm.generateTemplates(collected.enabledContracts, collected.adminFunctions, collected.nonSeparatedFunctions, collected.separatedByContract, collected.allContractNames, symbolsInfo);
     }
     async listAvailable() {
         var _a;

package/dist/index.js

@@ -336,8 +336,9 @@ async function main() {
     program
         .action(async (opts) => {
         const workspaceRoot = process.cwd();
-        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
-        const foundryRoot = path.dirname(foundryConfig);
+        const foundryConfigPath = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfigPath);
+        const forgeConfig = await (0, utils_1.getFoundryConfig)(foundryRoot);
         const includeFilter = parseFilter(opts.include);
         const excludeFilter = parseFilter(opts.exclude);
         const adminFilter = parseFilter(opts.admin);
@@ -356,7 +357,7 @@ async function main() {
         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) : await (0, utils_1.getTestFolder)(foundryRoot);
+        const baseOut = opts.output ? String(opts.output) : forgeConfig.test;
         const baseOutPath = path.isAbsolute(baseOut) ? baseOut : path.join(foundryRoot, baseOut);
         const suiteDir = path.join(baseOutPath, suiteFolderName);
         const reconDefaultName = suiteSnake ? `recon-${suiteSnake}.json` : 'recon.json';
@@ -368,7 +369,7 @@ async function main() {
         const generator = new generator_1.ReconGenerator(foundryRoot, {
             suiteDir,
             reconConfigPath: reconPath,
-            foundryConfigPath: foundryConfig,
+            foundryConfigPath: foundryConfigPath,
             include: includeFilter,
             exclude: excludeFilter,
             admin: adminFilter ? adminFilter.functions : undefined,
@@ -381,6 +382,7 @@ async function main() {
             suiteNamePascal: suitePascal,
             coverage: !!opts.coverage,
             params: !!opts.params,
+            foundryConfig: forgeConfig,
         });
         if (opts.list) {
             await generator.listAvailable();

package/dist/templateManager.d.ts

@@ -1,4 +1,5 @@
 import { FunctionDefinitionParams, ContractMetadata } from './types';
+import { SymbolsInfo } from './utils';
 export declare class TemplateManager {
     private foundryRoot;
     private suiteDir;
@@ -9,5 +10,5 @@ export declare class TemplateManager {
     private skipList;
     private shouldGenerateFile;
     private updateTargetFile;
-    generateTemplates(enabledContracts: ContractMetadata[], adminFunctions: FunctionDefinitionParams[], nonSeparatedFunctions: FunctionDefinitionParams[], separatedByContract: Record<string, FunctionDefinitionParams[]>, allContractNames: string[]): Promise<void>;
+    generateTemplates(enabledContracts: ContractMetadata[], adminFunctions: FunctionDefinitionParams[], nonSeparatedFunctions: FunctionDefinitionParams[], separatedByContract: Record<string, FunctionDefinitionParams[]>, allContractNames: string[], symbolsInfo?: SymbolsInfo): Promise<void>;
 }

package/dist/templateManager.js

@@ -38,6 +38,7 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const case_1 = require("case");
 const templates = __importStar(require("./templates"));
+const utils_1 = require("./utils");
 class TemplateManager {
     constructor(foundryRoot, suiteDir, suiteNameSnake, suiteNamePascal, dynamicDeploy = new Set()) {
         this.foundryRoot = foundryRoot;
@@ -96,7 +97,7 @@ class TemplateManager {
             return newContent;
         }
     }
-    async generateTemplates(enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames) {
+    async generateTemplates(enabledContracts, adminFunctions, nonSeparatedFunctions, separatedByContract, allContractNames, symbolsInfo) {
         const contractsForSetup = enabledContracts.map(contract => ({ ...contract, isDynamic: this.dynamicDeploy.has(contract.name) }));
         const dynamicContracts = enabledContracts
             .filter(contract => this.dynamicDeploy.has(contract.name))
@@ -120,16 +121,22 @@ class TemplateManager {
                 contracts: allContractNames,
                 dynamicContracts,
             }),
-            [path.join(suiteTargetsDir, 'AdminTargets.sol')]: templates.adminTargetsTemplate({ functions: adminFunctions }),
+            [path.join(suiteTargetsDir, 'AdminTargets.sol')]: templates.adminTargetsTemplate({
+                functions: adminFunctions,
+                extraImports: symbolsInfo ? (0, utils_1.resolveExtraImports)([], adminFunctions, symbolsInfo) : [],
+            }),
             [path.join(suiteTargetsDir, 'DoomsdayTargets.sol')]: templates.doomsdayTargetsTemplate({}),
             [path.join(suiteTargetsDir, 'ManagersTargets.sol')]: templates.managersTargetsTemplate({}),
         };
         for (const [contractName, functions] of Object.entries(separatedByContract)) {
             const targetPath = path.join(suiteTargetsDir, `${(0, case_1.pascal)(contractName)}Targets.sol`);
+            const contractPath = functions.length > 0 ? functions[0].contractPath : '';
+            const importedPaths = contractPath ? [contractPath] : [];
             files[targetPath] = templates.targetsTemplate({
                 contractName,
-                path: functions.length > 0 ? functions[0].contractPath : '',
+                path: contractPath,
                 functions,
+                extraImports: symbolsInfo ? (0, utils_1.resolveExtraImports)(importedPaths, functions, symbolsInfo) : [],
             });
         }
         for (const [name, content] of Object.entries(files)) {

package/dist/templates/targets/admin-targets.js

@@ -18,6 +18,9 @@ import {vm} from "@chimera/Hevm.sol";
 
 // Helpers
 import {Panic} from "@recon/Panic.sol";
+{{#each extraImports}}
+import { {{this.name}} } from "{{this.path}}";
+{{/each}}
 
 abstract contract AdminTargets is
     BaseTargetFunctions,

package/dist/templates/targets/targets.js

@@ -20,6 +20,9 @@ import {vm} from "@chimera/Hevm.sol";
 import {Panic} from "@recon/Panic.sol";
 
 {{#if path}}import "{{path}}";{{/if}}
+{{#each extraImports}}
+import { {{this.name}} } from "{{this.path}}";
+{{/each}}
 
 abstract contract {{pascal contractName}}Targets is
     BaseTargetFunctions,

package/dist/types.d.ts

@@ -98,3 +98,11 @@ export type CallTreeData = {
     function: FunctionDefinition;
     callTree: CallTree;
 };
+export interface FoundryConfig {
+    src: string;
+    test: string;
+    script: string;
+    out: string;
+    libs: string[];
+    remappings: string[];
+}

package/dist/utils.d.ts

@@ -1,10 +1,12 @@
 import { ASTNode, ContractDefinition, Assignment, FunctionCall, FunctionDefinition, SourceUnit, VariableDeclaration, EventDefinition, ErrorDefinition } from 'solc-typed-ast';
-import { CallType } from './types';
+import { CallType, FunctionDefinitionParams, FoundryConfig, ParamDefinition } from './types';
 export declare function fileExists(p: string): Promise<boolean>;
 export declare function getFoundryConfigPath(workspaceRoot: string, override?: string): string;
 export declare function findOutputDirectory(workspaceRoot: string, foundryConfigPath: string): Promise<string>;
 export declare function findSrcDirectory(workspaceRoot: string, foundryConfigPath: string): Promise<string>;
 export declare function getTestFolder(foundryRoot: string): Promise<string>;
+export declare const FOUNDRY_CONFIG_DEFAULTS: FoundryConfig;
+export declare function getFoundryConfig(foundryRoot: string): Promise<FoundryConfig>;
 export declare function stripAnsiCodes(text: string): string;
 export declare function getEnvPath(): string;
 export declare const getLines: (content: string, src: string) => {
@@ -72,3 +74,30 @@ export declare const loadBuildInfoFromFile: (buildInfoPath: string, skipPatterns
  * @returns Object containing sourceUnits and raw buildOutput
  */
 export declare const loadLatestBuildInfo: (foundryRoot: string, outputDir?: string, skipPatterns?: string[]) => Promise<BuildInfoResult>;
+/**
+ * Recursively walks parameter internalType fields and extracts referenced type names.
+ * For dotted types like "struct ISpoke.DynamicReserveConfig" → extracts "ISpoke"
+ * For "contract ISpoke" (no dot) → extracts "ISpoke"
+ * Skips primitives.
+ */
+export declare function collectReferencedTypeNames(params: ParamDefinition[]): Set<string>;
+export interface SymbolsInfo {
+    byFile: Map<string, Set<string>>;
+    definedIn: Map<string, string>;
+}
+/**
+ * Builds maps of exported symbols per file and definition locations from the raw build output.
+ * - byFile: file path → set of exported symbol names
+ * - definedIn: symbol name → file path where it's actually defined (top-level definitions)
+ */
+export declare function buildExportedSymbolsMap(buildOutput: any): SymbolsInfo;
+export interface ExtraImport {
+    name: string;
+    path: string;
+}
+/**
+ * Given imported file paths, function definitions, and symbol maps, returns a list of
+ * named imports needed for types referenced in function parameters but not available
+ * through already-imported files.
+ */
+export declare function resolveExtraImports(importedPaths: string[], functions: FunctionDefinitionParams[], symbolsInfo: SymbolsInfo): ExtraImport[];

package/dist/utils.js

@@ -36,12 +36,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadLatestBuildInfo = exports.loadBuildInfoFromFile = exports.parseBuildOutput = exports.signatureEquals = exports.getFunctionName = exports.getIndex = exports.getSource = exports.getLines = void 0;
+exports.loadLatestBuildInfo = exports.loadBuildInfoFromFile = exports.parseBuildOutput = exports.signatureEquals = exports.getFunctionName = exports.getIndex = exports.getSource = exports.getLines = exports.FOUNDRY_CONFIG_DEFAULTS = void 0;
 exports.fileExists = fileExists;
 exports.getFoundryConfigPath = getFoundryConfigPath;
 exports.findOutputDirectory = findOutputDirectory;
 exports.findSrcDirectory = findSrcDirectory;
 exports.getTestFolder = getTestFolder;
+exports.getFoundryConfig = getFoundryConfig;
 exports.stripAnsiCodes = stripAnsiCodes;
 exports.getEnvPath = getEnvPath;
 exports.highLevelCallWithOptions = highLevelCallWithOptions;
@@ -64,10 +65,14 @@ exports.resolveOverride = resolveOverride;
 exports.idToContract = idToContract;
 exports.forwardLinearization = forwardLinearization;
 exports.resolveSuper = resolveSuper;
+exports.collectReferencedTypeNames = collectReferencedTypeNames;
+exports.buildExportedSymbolsMap = buildExportedSymbolsMap;
+exports.resolveExtraImports = resolveExtraImports;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const solc_typed_ast_1 = require("solc-typed-ast");
 const src_location_1 = __importDefault(require("src-location"));
+const child_process_1 = require("child_process");
 const types_1 = require("./types");
 async function fileExists(p) {
     try {
@@ -125,6 +130,41 @@ async function getTestFolder(foundryRoot) {
     }
     return 'test';
 }
+exports.FOUNDRY_CONFIG_DEFAULTS = {
+    src: 'src',
+    test: 'test',
+    script: 'script',
+    out: 'out',
+    libs: ['lib'],
+    remappings: [],
+};
+function getFoundryConfig(foundryRoot) {
+    return new Promise((resolve) => {
+        (0, child_process_1.exec)('forge config --json', {
+            cwd: foundryRoot,
+            env: { ...process.env, PATH: getEnvPath() },
+        }, (err, stdout) => {
+            if (err) {
+                resolve({ ...exports.FOUNDRY_CONFIG_DEFAULTS });
+                return;
+            }
+            try {
+                const raw = JSON.parse(stdout);
+                resolve({
+                    src: typeof raw.src === 'string' ? raw.src : exports.FOUNDRY_CONFIG_DEFAULTS.src,
+                    test: typeof raw.test === 'string' ? raw.test : exports.FOUNDRY_CONFIG_DEFAULTS.test,
+                    script: typeof raw.script === 'string' ? raw.script : exports.FOUNDRY_CONFIG_DEFAULTS.script,
+                    out: typeof raw.out === 'string' ? raw.out : exports.FOUNDRY_CONFIG_DEFAULTS.out,
+                    libs: Array.isArray(raw.libs) ? raw.libs.filter((l) => typeof l === 'string') : exports.FOUNDRY_CONFIG_DEFAULTS.libs,
+                    remappings: Array.isArray(raw.remappings) ? raw.remappings.filter((r) => typeof r === 'string') : exports.FOUNDRY_CONFIG_DEFAULTS.remappings,
+                });
+            }
+            catch {
+                resolve({ ...exports.FOUNDRY_CONFIG_DEFAULTS });
+            }
+        });
+    });
+}
 function stripAnsiCodes(text) {
     return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
 }
@@ -517,3 +557,132 @@ const loadLatestBuildInfo = async (foundryRoot, outputDir = 'out', skipPatterns
     return (0, exports.loadBuildInfoFromFile)(latestFile, skipPatterns);
 };
 exports.loadLatestBuildInfo = loadLatestBuildInfo;
+// --- Extra import resolution utilities ---
+const PRIMITIVE_TYPES = new Set([
+    'address', 'bool', 'string', 'bytes',
+    'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',
+    'int8', 'int16', 'int32', 'int64', 'int128', 'int256',
+    'bytes1', 'bytes2', 'bytes3', 'bytes4', 'bytes5', 'bytes6', 'bytes7', 'bytes8',
+    'bytes9', 'bytes10', 'bytes11', 'bytes12', 'bytes13', 'bytes14', 'bytes15', 'bytes16',
+    'bytes17', 'bytes18', 'bytes19', 'bytes20', 'bytes21', 'bytes22', 'bytes23', 'bytes24',
+    'bytes25', 'bytes26', 'bytes27', 'bytes28', 'bytes29', 'bytes30', 'bytes31', 'bytes32',
+]);
+/**
+ * Recursively walks parameter internalType fields and extracts referenced type names.
+ * For dotted types like "struct ISpoke.DynamicReserveConfig" → extracts "ISpoke"
+ * For "contract ISpoke" (no dot) → extracts "ISpoke"
+ * Skips primitives.
+ */
+function collectReferencedTypeNames(params) {
+    const names = new Set();
+    const walk = (p) => {
+        if (p.components && p.components.length > 0) {
+            for (const c of p.components) {
+                walk(c);
+            }
+        }
+        const raw = p.internalType;
+        if (!raw)
+            return;
+        // Strip prefix keywords: "struct ", "enum ", "contract "
+        let cleaned = raw.replace(/^(struct|enum|contract)\s+/, '').trim();
+        // Strip array suffixes like "[]" or "[5]"
+        cleaned = cleaned.replace(/(\[.*\])+$/, '');
+        if (!cleaned || PRIMITIVE_TYPES.has(cleaned))
+            return;
+        // If dotted, extract prefix (e.g., "ISpoke.DynamicReserveConfig" → "ISpoke")
+        const dotIdx = cleaned.indexOf('.');
+        if (dotIdx > 0) {
+            names.add(cleaned.substring(0, dotIdx));
+        }
+        else {
+            // Standalone type name (e.g., "ISpoke" from "contract ISpoke")
+            names.add(cleaned);
+        }
+    };
+    for (const p of params) {
+        walk(p);
+    }
+    return names;
+}
+/**
+ * Builds maps of exported symbols per file and definition locations from the raw build output.
+ * - byFile: file path → set of exported symbol names
+ * - definedIn: symbol name → file path where it's actually defined (top-level definitions)
+ */
+function buildExportedSymbolsMap(buildOutput) {
+    const byFile = new Map();
+    const definedIn = new Map();
+    if (!(buildOutput === null || buildOutput === void 0 ? void 0 : buildOutput.sources)) {
+        return { byFile, definedIn };
+    }
+    for (const [filePath, sourceData] of Object.entries(buildOutput.sources)) {
+        const ast = sourceData === null || sourceData === void 0 ? void 0 : sourceData.ast;
+        if (!ast)
+            continue;
+        // Populate byFile from exportedSymbols
+        const exported = ast.exportedSymbols;
+        if (exported && typeof exported === 'object') {
+            const symbolSet = new Set(Object.keys(exported));
+            byFile.set(filePath, symbolSet);
+        }
+        // Populate definedIn from top-level AST nodes
+        const nodes = ast.nodes;
+        if (Array.isArray(nodes)) {
+            for (const node of nodes) {
+                const nodeType = node === null || node === void 0 ? void 0 : node.nodeType;
+                if (nodeType === 'ContractDefinition' ||
+                    nodeType === 'StructDefinition' ||
+                    nodeType === 'EnumDefinition' ||
+                    nodeType === 'UserDefinedValueTypeDefinition') {
+                    const name = node.name;
+                    if (name && typeof name === 'string') {
+                        definedIn.set(name, filePath);
+                    }
+                }
+            }
+        }
+    }
+    return { byFile, definedIn };
+}
+/**
+ * Given imported file paths, function definitions, and symbol maps, returns a list of
+ * named imports needed for types referenced in function parameters but not available
+ * through already-imported files.
+ */
+function resolveExtraImports(importedPaths, functions, symbolsInfo) {
+    // Collect all referenced type names from all function inputs and outputs
+    const allParams = [];
+    for (const fn of functions) {
+        if (fn.abi.inputs)
+            allParams.push(...fn.abi.inputs);
+        if (fn.abi.outputs)
+            allParams.push(...fn.abi.outputs);
+    }
+    const referenced = collectReferencedTypeNames(allParams);
+    if (referenced.size === 0)
+        return [];
+    // Collect available symbols from already-imported files
+    const available = new Set();
+    for (const importPath of importedPaths) {
+        const symbols = symbolsInfo.byFile.get(importPath);
+        if (symbols) {
+            for (const s of symbols) {
+                available.add(s);
+            }
+        }
+    }
+    // For each referenced type not available, find its definition file
+    const results = [];
+    const seen = new Set();
+    for (const typeName of Array.from(referenced).sort()) {
+        if (available.has(typeName))
+            continue;
+        const defFile = symbolsInfo.definedIn.get(typeName);
+        if (defFile && !seen.has(typeName)) {
+            seen.add(typeName);
+            results.push({ name: typeName, path: defFile });
+        }
+    }
+    return results;
+}

package/package.json

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