recon-generate 0.0.34 → 0.0.36

package/dist/db.d.ts

@@ -0,0 +1,4 @@
+export declare const runDb: (foundryRoot: string, options?: {
+    output?: string;
+    forceBuild?: boolean;
+}) => Promise<void>;

package/dist/db.js

@@ -0,0 +1,185 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDb = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const db_1 = require("./ingestion/db");
+const ingestion_1 = require("./ingestion");
+const utils_1 = require("./utils");
+/**
+ * Normalize build-info JSON into compiler output + version.
+ */
+function normalizeCompilerOutput(data) {
+    if (data.sources && !data.output) {
+        return { output: data, compilerVersion: null };
+    }
+    if (data.output && data.output.sources) {
+        return {
+            output: data.output,
+            compilerVersion: data.solcVersion || data.solcLongVersion || null,
+        };
+    }
+    if (data.output && typeof data.output === 'object') {
+        return {
+            output: data.output,
+            compilerVersion: data.solcVersion || null,
+        };
+    }
+    throw new Error('Unrecognized JSON format. Expected either:\n' +
+        '  - Standard solc compiler output (with \'sources\' key)\n' +
+        '  - Foundry build-info JSON (with \'output.sources\')\n' +
+        'Run: solc --combined-json ast <file.sol>\n' +
+        '  or: forge build --build-info');
+}
+function 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();
+            }
+        });
+    });
+}
+/**
+ * Build into .recon/out with --build-info, skipping test/script dirs.
+ * Reuses existing build if .recon/out already exists (unless forceBuild).
+ */
+async function ensureBuild(foundryRoot, forceBuild) {
+    const reconOutDir = path.join(foundryRoot, '.recon', 'out');
+    if (!forceBuild && await (0, utils_1.fileExists)(reconOutDir)) {
+        console.log('[recon-generate] Using existing .recon/out build');
+        return;
+    }
+    const reconDir = path.join(foundryRoot, '.recon');
+    if (!fs.existsSync(reconDir)) {
+        fs.mkdirSync(reconDir, { recursive: true });
+    }
+    const config = await (0, utils_1.getFoundryConfig)(foundryRoot);
+    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();
+    console.log(`[recon-generate] Building: ${cmd}`);
+    await runCmd(cmd, foundryRoot);
+}
+/**
+ * Load the latest build-info JSON file from .recon/out/build-info.
+ */
+function loadBuildInfoRaw(foundryRoot) {
+    const buildInfoDir = path.join(foundryRoot, '.recon', 'out', 'build-info');
+    let files = [];
+    try {
+        const entries = fs.readdirSync(buildInfoDir);
+        const jsonFiles = entries.filter((f) => f.endsWith('.json'));
+        files = jsonFiles.map((f) => {
+            const fullPath = path.join(buildInfoDir, f);
+            return { name: f, fullPath, mtime: fs.statSync(fullPath).mtime };
+        });
+    }
+    catch {
+        throw new Error(`No build-info directory found at ${buildInfoDir}. Run: forge build --build-info`);
+    }
+    if (files.length === 0) {
+        throw new Error(`No build-info JSON files found in ${buildInfoDir}. Run: forge build --build-info`);
+    }
+    const latestFile = files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0];
+    console.log(`[recon-generate] Using build-info: ${latestFile.name}`);
+    const stat = fs.statSync(latestFile.fullPath);
+    console.log(`[recon-generate] Reading build-info (${(stat.size / 1024 / 1024).toFixed(1)} MB)...`);
+    const rawContent = fs.readFileSync(latestFile.fullPath, 'utf-8');
+    console.log(`[recon-generate] Parsing JSON...`);
+    const parsed = JSON.parse(rawContent);
+    const { output, compilerVersion: detectedVersion } = normalizeCompilerOutput(parsed);
+    const compilerVersion = detectedVersion || '0.8.0';
+    return { raw: parsed, output, compilerVersion };
+}
+/**
+ * Extract source contents from build-info input.sources
+ */
+function extractSourceContents(raw) {
+    var _a;
+    const sourceContents = new Map();
+    if ((_a = raw.input) === null || _a === void 0 ? void 0 : _a.sources) {
+        for (const [filePath, entry] of Object.entries(raw.input.sources)) {
+            if (entry === null || entry === void 0 ? void 0 : entry.content) {
+                sourceContents.set(filePath, entry.content);
+            }
+        }
+    }
+    return sourceContents;
+}
+const runDb = async (foundryRoot, options = {}) => {
+    // Build into .recon/out (skipping test/script), reuse if already present
+    await ensureBuild(foundryRoot, !!options.forceBuild);
+    // Load latest build-info from .recon/out
+    const { raw, output, compilerVersion } = loadBuildInfoRaw(foundryRoot);
+    const sourceContents = extractSourceContents(raw);
+    console.log(`[recon-generate] Compiler version: ${compilerVersion}`);
+    if (sourceContents.size > 0) {
+        console.log(`[recon-generate] Found ${sourceContents.size} source content entries`);
+    }
+    // Determine DB path
+    const reconDir = path.join(foundryRoot, '.recon');
+    if (!fs.existsSync(reconDir)) {
+        fs.mkdirSync(reconDir, { recursive: true });
+    }
+    const dbPath = options.output
+        ? (path.isAbsolute(options.output) ? options.output : path.join(foundryRoot, options.output))
+        : path.join(reconDir, 'db.sqlite');
+    // Remove existing DB to start fresh
+    if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+    }
+    console.log(`[recon-generate] Creating database at ${dbPath}`);
+    const db = (0, db_1.createDatabase)(dbPath);
+    try {
+        const sourceUnits = (0, ingestion_1.ingest)(db, output, {
+            compilerVersion,
+            sourceContents,
+            compilerContracts: output.contracts,
+        });
+        console.log(`[recon-generate] Ingested ${sourceUnits.length} source unit(s)`);
+    }
+    finally {
+        db.close();
+    }
+    console.log(`[recon-generate] Done. Database written to ${dbPath}`);
+};
+exports.runDb = runDb;

package/dist/index.js

@@ -47,6 +47,7 @@ const link_1 = require("./link");
 const link2_1 = require("./link2");
 const sourcemap_1 = require("./sourcemap");
 const dictionary_1 = require("./dictionary");
+const db_1 = require("./db");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageJson = require('../package.json');
 function parseFilter(input) {
@@ -286,6 +287,20 @@ async function main() {
             : undefined;
         await (0, info_1.runInfo)(foundryRoot, contractName, { outputPath, json: !!opts.json });
     });
+    program
+        .command('db')
+        .description('Ingest Solidity AST from build-info into a SQLite database (.recon/db.sqlite)')
+        .option('-o, --output <path>', 'Custom output path for the database file')
+        .option('--force-build', 'Delete .recon/out to force a fresh forge build before ingesting')
+        .option('--foundry-config <path>', 'Path to foundry.toml (defaults to ./foundry.toml)')
+        .action(async function () {
+        // @ts-ignore - Commander types are complex
+        const opts = this.opts();
+        const workspaceRoot = process.cwd();
+        const foundryConfig = (0, utils_1.getFoundryConfigPath)(workspaceRoot, opts.foundryConfig);
+        const foundryRoot = path.dirname(foundryConfig);
+        await (0, db_1.runDb)(foundryRoot, { output: opts.output, forceBuild: !!opts.forceBuild });
+    });
     program
         .command('wake')
         .description('Generate Python fuzzing suite using Wake framework')

package/dist/ingestion/db.d.ts

@@ -0,0 +1,4 @@
+import Database from "better-sqlite3";
+export declare function openDatabase(dbPath: string): Database.Database;
+export declare function initializeSchema(db: Database.Database): void;
+export declare function createDatabase(dbPath: string): Database.Database;

package/dist/ingestion/db.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDatabase = openDatabase;
+exports.initializeSchema = initializeSchema;
+exports.createDatabase = createDatabase;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const schema_1 = require("./schema");
+function openDatabase(dbPath) {
+    const db = new better_sqlite3_1.default(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    db.pragma("synchronous = NORMAL");
+    return db;
+}
+function initializeSchema(db) {
+    db.exec(schema_1.SCHEMA_SQL);
+}
+function createDatabase(dbPath) {
+    const db = openDatabase(dbPath);
+    initializeSchema(db);
+    return db;
+}

package/dist/ingestion/handlers.d.ts

@@ -0,0 +1,64 @@
+import type Database from "better-sqlite3";
+import type { ASTNode } from "solc-typed-ast";
+export interface PreparedStatements {
+    insertSourceUnit: Database.Statement;
+    insertAstNode: Database.Statement;
+    insertEdge: Database.Statement;
+    insertContract: Database.Statement;
+    insertFunction: Database.Statement;
+    insertModifier: Database.Statement;
+    insertVariable: Database.Statement;
+    insertStruct: Database.Statement;
+    insertEnum: Database.Statement;
+    insertEnumValue: Database.Statement;
+    insertEvent: Database.Statement;
+    insertError: Database.Statement;
+    insertUserDefinedValueType: Database.Statement;
+    insertIdentifier: Database.Statement;
+    insertLiteral: Database.Statement;
+    insertBinaryOperation: Database.Statement;
+    insertUnaryOperation: Database.Statement;
+    insertAssignment: Database.Statement;
+    insertConditional: Database.Statement;
+    insertFunctionCall: Database.Statement;
+    insertFunctionCallOptions: Database.Statement;
+    insertMemberAccess: Database.Statement;
+    insertIndexAccess: Database.Statement;
+    insertIndexRangeAccess: Database.Statement;
+    insertTupleExpression: Database.Statement;
+    insertNewExpression: Database.Statement;
+    insertElementaryTypeNameExpression: Database.Statement;
+    insertIfStatement: Database.Statement;
+    insertForStatement: Database.Statement;
+    insertWhileStatement: Database.Statement;
+    insertDoWhileStatement: Database.Statement;
+    insertTryStatement: Database.Statement;
+    insertTryCatchClause: Database.Statement;
+    insertVariableDeclarationStatement: Database.Statement;
+    insertEmitStatement: Database.Statement;
+    insertRevertStatement: Database.Statement;
+    insertInlineAssembly: Database.Statement;
+    insertBlock: Database.Statement;
+    insertExpressionStatement: Database.Statement;
+    insertReturnStatement: Database.Statement;
+    insertElementaryTypeName: Database.Statement;
+    insertUserDefinedTypeName: Database.Statement;
+    insertFunctionTypeName: Database.Statement;
+    insertMappingTypeName: Database.Statement;
+    insertArrayTypeName: Database.Statement;
+    insertPragma: Database.Statement;
+    insertImport: Database.Statement;
+    insertInheritanceSpecifier: Database.Statement;
+    insertModifierInvocation: Database.Statement;
+    insertParameterList: Database.Statement;
+    insertIdentifierPath: Database.Statement;
+    insertStructuredDoc: Database.Statement;
+    insertUsingForDirective: Database.Statement;
+    insertOverrideSpecifier: Database.Statement;
+    insertYulNode: Database.Statement;
+    insertYulEdge: Database.Statement;
+}
+export declare function createPreparedStatements(db: Database.Database): PreparedStatements;
+type Handler = (node: ASTNode, stmts: PreparedStatements) => void;
+declare const handlers: Map<string, Handler>;
+export { handlers };