recon-generate 0.0.2 → 0.0.3

package/dist/generator.d.ts

@@ -21,6 +21,7 @@ export declare class ReconGenerator {
     private options;
     private generatedMocks;
     private allowedMockNames;
+    private contractKindCache;
     constructor(foundryRoot: string, options: GeneratorOptions);
     private logDebug;
     private outDir;
@@ -33,6 +34,7 @@ export declare class ReconGenerator {
     private installSetupHelpers;
     private updateRemappings;
     private updateGitignore;
+    private getContractKind;
     private findSourceContracts;
     private matchesSignatureOrName;
     private paramType;

package/dist/generator.js

@@ -41,6 +41,7 @@ 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 parser_1 = __importDefault(require("@solidity-parser/parser"));
 const templateManager_1 = require("./templateManager");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
@@ -50,6 +51,7 @@ class ReconGenerator {
         this.options = options;
         this.generatedMocks = new Set();
         this.allowedMockNames = new Set();
+        this.contractKindCache = new Map();
     }
     logDebug(message, obj) {
         if (!this.options.debug)
@@ -153,6 +155,45 @@ class ReconGenerator {
             await fs.writeFile(gitignorePath, content);
         }
     }
+    async getContractKind(sourcePath, contractName) {
+        const absPath = path.isAbsolute(sourcePath) ? sourcePath : path.join(this.foundryRoot, sourcePath);
+        let fileCache = this.contractKindCache.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 contract kind', { sourcePath, error: String(e) });
+            return 'unknown';
+        }
+        let ast;
+        try {
+            ast = parser_1.default.parse(content, { tolerant: true });
+        }
+        catch (e) {
+            this.logDebug('Failed to parse source when determining contract kind', { sourcePath, error: String(e) });
+            return 'unknown';
+        }
+        fileCache = fileCache !== null && fileCache !== void 0 ? fileCache : new Map();
+        let kind = 'unknown';
+        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.kind === 'contract' || node.kind === 'interface' || node.kind === 'library') {
+                        kind = node.kind;
+                    }
+                    break;
+                }
+            }
+        }
+        fileCache.set(contractName, kind);
+        this.contractKindCache.set(absPath, fileCache);
+        return kind;
+    }
     async findSourceContracts() {
         var _a;
         const contracts = [];
@@ -181,18 +222,14 @@ class ReconGenerator {
                             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 contractKind = await this.getContractKind(sourcePath, String(contractName));
+                                if (contractKind === 'interface' || contractKind === 'library') {
+                                    this.logDebug('Skipping non-contract artifact', { contractName, sourcePath, contractKind });
+                                    continue;
+                                }
+                                if (!isGeneratedMock && (lowerPath.includes('/mock') || lowerName.includes('mock'))) {
+                                    continue;
                                 }
                                 const relativeJson = path.relative(this.foundryRoot, filePath);
                                 let displayedPath = sourcePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {
@@ -18,9 +18,10 @@
     "package.json"
   ],
   "dependencies": {
+    "@solidity-parser/parser": "^0.20.2",
     "abi-to-mock": "^1.0.4",
     "case": "^1.6.3",
-    "commander": "^12.1.0",
+    "commander": "^14.0.2",
     "handlebars": "^4.7.8"
   },
   "devDependencies": {