@ophan/core 0.0.1

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,492 @@
+"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 });
+const vitest_1 = require("vitest");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+const test_utils_1 = require("./test-utils");
+// ============ mergeAnalysisRows ============
+(0, vitest_1.describe)("mergeAnalysisRows", () => {
+    (0, vitest_1.it)("merges documentation + security rows into unified shape", () => {
+        const result = (0, index_1.mergeAnalysisRows)([
+            {
+                analysis_type: "documentation",
+                analysis: JSON.stringify({
+                    description: "Fetches user",
+                    params: [{ name: "id", type: "string", description: "user id" }],
+                    returns: { type: "User", description: "the user" },
+                }),
+            },
+            {
+                analysis_type: "security",
+                analysis: JSON.stringify({
+                    dataTags: ["database", "pii"],
+                    securityFlags: ["sql_injection"],
+                }),
+            },
+        ]);
+        (0, vitest_1.expect)(result.description).toBe("Fetches user");
+        (0, vitest_1.expect)(result.params).toEqual([
+            { name: "id", type: "string", description: "user id" },
+        ]);
+        (0, vitest_1.expect)(result.returns).toEqual({ type: "User", description: "the user" });
+        (0, vitest_1.expect)(result.dataTags).toEqual(["database", "pii"]);
+        (0, vitest_1.expect)(result.securityFlags).toEqual(["sql_injection"]);
+    });
+    (0, vitest_1.it)("handles documentation-only (missing security row)", () => {
+        const result = (0, index_1.mergeAnalysisRows)([
+            {
+                analysis_type: "documentation",
+                analysis: JSON.stringify({
+                    description: "Test",
+                    params: [],
+                    returns: { type: "void", description: "" },
+                }),
+            },
+        ]);
+        (0, vitest_1.expect)(result.description).toBe("Test");
+        (0, vitest_1.expect)(result.dataTags).toEqual([]);
+        (0, vitest_1.expect)(result.securityFlags).toEqual([]);
+    });
+    (0, vitest_1.it)("handles security-only (missing documentation row)", () => {
+        const result = (0, index_1.mergeAnalysisRows)([
+            {
+                analysis_type: "security",
+                analysis: JSON.stringify({
+                    dataTags: ["internal"],
+                    securityFlags: [],
+                }),
+            },
+        ]);
+        (0, vitest_1.expect)(result.description).toBe("");
+        (0, vitest_1.expect)(result.params).toEqual([]);
+        (0, vitest_1.expect)(result.returns).toEqual({ type: "unknown", description: "" });
+        (0, vitest_1.expect)(result.dataTags).toEqual(["internal"]);
+    });
+    (0, vitest_1.it)("handles empty rows array", () => {
+        const result = (0, index_1.mergeAnalysisRows)([]);
+        (0, vitest_1.expect)(result.description).toBe("");
+        (0, vitest_1.expect)(result.params).toEqual([]);
+        (0, vitest_1.expect)(result.returns).toEqual({ type: "unknown", description: "" });
+        (0, vitest_1.expect)(result.dataTags).toEqual([]);
+        (0, vitest_1.expect)(result.securityFlags).toEqual([]);
+    });
+    (0, vitest_1.it)("ignores unknown analysis_type", () => {
+        const result = (0, index_1.mergeAnalysisRows)([
+            {
+                analysis_type: "future_type",
+                analysis: JSON.stringify({ foo: "bar" }),
+            },
+        ]);
+        (0, vitest_1.expect)(result.description).toBe("");
+        (0, vitest_1.expect)(result.securityFlags).toEqual([]);
+    });
+    (0, vitest_1.it)("last row wins when duplicate analysis_type", () => {
+        const result = (0, index_1.mergeAnalysisRows)([
+            {
+                analysis_type: "documentation",
+                analysis: JSON.stringify({
+                    description: "First",
+                    params: [],
+                    returns: { type: "void", description: "" },
+                }),
+            },
+            {
+                analysis_type: "documentation",
+                analysis: JSON.stringify({
+                    description: "Second",
+                    params: [],
+                    returns: { type: "string", description: "overwritten" },
+                }),
+            },
+        ]);
+        (0, vitest_1.expect)(result.description).toBe("Second");
+        (0, vitest_1.expect)(result.returns.type).toBe("string");
+    });
+});
+// ============ migrateToAnalysisTypes ============
+(0, vitest_1.describe)("migrateToAnalysisTypes", () => {
+    (0, vitest_1.it)("splits single legacy row into documentation + security rows", () => {
+        const db = (0, test_utils_1.createLegacyTestDb)();
+        db.prepare(`INSERT INTO function_analysis
+       (content_hash, analysis, model_version, created_at, last_seen_at, language, entity_type, synced_at)
+       VALUES (?, ?, 'claude-3', 1000, 2000, 'typescript', 'function', 5000)`).run("abc123", JSON.stringify({
+            description: "Test fn",
+            params: [{ name: "x", type: "number", description: "input" }],
+            returns: { type: "number", description: "output" },
+            dataTags: ["internal"],
+            securityFlags: ["xss"],
+        }));
+        (0, index_1.migrateToAnalysisTypes)(db);
+        const rows = db
+            .prepare("SELECT content_hash, analysis_type, analysis, synced_at FROM function_analysis ORDER BY analysis_type")
+            .all();
+        (0, vitest_1.expect)(rows).toHaveLength(2);
+        const docRow = rows.find((r) => r.analysis_type === "documentation");
+        const secRow = rows.find((r) => r.analysis_type === "security");
+        (0, vitest_1.expect)(docRow).toBeDefined();
+        (0, vitest_1.expect)(secRow).toBeDefined();
+        const doc = JSON.parse(docRow.analysis);
+        (0, vitest_1.expect)(doc.description).toBe("Test fn");
+        (0, vitest_1.expect)(doc.params).toEqual([
+            { name: "x", type: "number", description: "input" },
+        ]);
+        const sec = JSON.parse(secRow.analysis);
+        (0, vitest_1.expect)(sec.dataTags).toEqual(["internal"]);
+        (0, vitest_1.expect)(sec.securityFlags).toEqual(["xss"]);
+        // synced_at should be NULL (forced re-sync)
+        (0, vitest_1.expect)(docRow.synced_at).toBeNull();
+        (0, vitest_1.expect)(secRow.synced_at).toBeNull();
+        db.close();
+    });
+    (0, vitest_1.it)("handles NULL language/entity_type with COALESCE defaults", () => {
+        const db = (0, test_utils_1.createLegacyTestDb)();
+        db.prepare(`INSERT INTO function_analysis
+       (content_hash, analysis, model_version, created_at, last_seen_at, language, entity_type)
+       VALUES (?, ?, 'claude-3', 1000, 2000, NULL, NULL)`).run("hash1", JSON.stringify({ description: "Test" }));
+        (0, index_1.migrateToAnalysisTypes)(db);
+        const rows = db
+            .prepare("SELECT language, entity_type FROM function_analysis WHERE content_hash = 'hash1'")
+            .all();
+        for (const row of rows) {
+            (0, vitest_1.expect)(row.language).toBe("typescript");
+            (0, vitest_1.expect)(row.entity_type).toBe("function");
+        }
+        db.close();
+    });
+    (0, vitest_1.it)("splits multiple legacy rows", () => {
+        const db = (0, test_utils_1.createLegacyTestDb)();
+        for (let i = 1; i <= 3; i++) {
+            db.prepare(`INSERT INTO function_analysis
+         (content_hash, analysis, model_version, created_at, last_seen_at)
+         VALUES (?, ?, 'claude-3', 1000, 2000)`).run(`hash${i}`, JSON.stringify({ description: `Fn ${i}` }));
+        }
+        (0, index_1.migrateToAnalysisTypes)(db);
+        const count = db
+            .prepare("SELECT COUNT(*) as c FROM function_analysis")
+            .get();
+        (0, vitest_1.expect)(count.c).toBe(6); // 3 hashes x 2 types
+        db.close();
+    });
+    (0, vitest_1.it)("new table has correct composite PK (content_hash, analysis_type)", () => {
+        const db = (0, test_utils_1.createLegacyTestDb)();
+        db.prepare(`INSERT INTO function_analysis
+       (content_hash, analysis, model_version, created_at, last_seen_at)
+       VALUES (?, ?, 'claude-3', 1000, 2000)`).run("hash1", JSON.stringify({}));
+        (0, index_1.migrateToAnalysisTypes)(db);
+        // Inserting duplicate (same hash + type) should fail
+        (0, vitest_1.expect)(() => db
+            .prepare(`INSERT INTO function_analysis
+           (content_hash, analysis_type, analysis, model_version, schema_version, created_at, last_seen_at, language, entity_type)
+           VALUES ('hash1', 'documentation', '{}', 'test', 1, 1000, 2000, 'typescript', 'function')`)
+            .run()).toThrow();
+        db.close();
+    });
+});
+// ============ gcAnalysis ============
+(0, vitest_1.describe)("gcAnalysis", () => {
+    let tmpDir;
+    let dbPath;
+    function setupDb(setup) {
+        const db = new better_sqlite3_1.default(dbPath);
+        // Create schema
+        const memDb = (0, test_utils_1.createTestDb)();
+        const tables = memDb
+            .prepare("SELECT sql FROM sqlite_master WHERE type='table'")
+            .all();
+        for (const t of tables) {
+            db.exec(t.sql + ";");
+        }
+        const indexes = memDb
+            .prepare("SELECT sql FROM sqlite_master WHERE type='index' AND sql IS NOT NULL")
+            .all();
+        for (const idx of indexes) {
+            db.exec(idx.sql + ";");
+        }
+        memDb.close();
+        setup(db);
+        db.close();
+    }
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ophan-gc-test-"));
+        dbPath = path.join(tmpDir, "index.db");
+    });
+    (0, vitest_1.afterEach)(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("deletes orphaned analysis older than grace period", () => {
+        const ninetyDaysAgo = Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60;
+        setupDb((db) => {
+            (0, test_utils_1.insertAnalysisPair)(db, "orphan1", { lastSeenAt: ninetyDaysAgo });
+            // No file_functions entry → orphaned
+        });
+        const result = (0, index_1.gcAnalysis)(dbPath, 30);
+        (0, vitest_1.expect)(result.deleted).toBe(2); // doc + sec rows
+        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        const remaining = db
+            .prepare("SELECT COUNT(*) as c FROM function_analysis")
+            .get();
+        (0, vitest_1.expect)(remaining.c).toBe(0);
+        db.close();
+    });
+    (0, vitest_1.it)("preserves analysis still referenced by file_functions", () => {
+        const ninetyDaysAgo = Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60;
+        setupDb((db) => {
+            (0, test_utils_1.insertAnalysisPair)(db, "active1", { lastSeenAt: ninetyDaysAgo });
+            (0, test_utils_1.insertFileFunction)(db, "/src/foo.ts", "foo", "active1");
+        });
+        const result = (0, index_1.gcAnalysis)(dbPath, 30);
+        (0, vitest_1.expect)(result.deleted).toBe(0);
+    });
+    (0, vitest_1.it)("preserves orphaned analysis within grace period", () => {
+        const fiveDaysAgo = Math.floor(Date.now() / 1000) - 5 * 24 * 60 * 60;
+        setupDb((db) => {
+            (0, test_utils_1.insertAnalysisPair)(db, "recent_orphan", { lastSeenAt: fiveDaysAgo });
+        });
+        const result = (0, index_1.gcAnalysis)(dbPath, 30);
+        (0, vitest_1.expect)(result.deleted).toBe(0);
+    });
+    (0, vitest_1.it)("creates tombstones in function_gc before deleting", () => {
+        const ninetyDaysAgo = Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60;
+        setupDb((db) => {
+            (0, test_utils_1.insertAnalysisPair)(db, "doomed", { lastSeenAt: ninetyDaysAgo });
+        });
+        (0, index_1.gcAnalysis)(dbPath, 30);
+        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        const tombstones = db
+            .prepare("SELECT content_hash, analysis_type FROM function_gc ORDER BY analysis_type")
+            .all();
+        (0, vitest_1.expect)(tombstones).toHaveLength(2);
+        (0, vitest_1.expect)(tombstones.map((t) => t.analysis_type).sort()).toEqual([
+            "documentation",
+            "security",
+        ]);
+        db.close();
+    });
+    (0, vitest_1.it)("handles empty database", () => {
+        setupDb(() => { });
+        const result = (0, index_1.gcAnalysis)(dbPath, 30);
+        (0, vitest_1.expect)(result.deleted).toBe(0);
+    });
+});
+// ============ importAnalysis ============
+(0, vitest_1.describe)("importAnalysis", () => {
+    let tmpDir;
+    let dbPath;
+    function setupDb(setup) {
+        const db = new better_sqlite3_1.default(dbPath);
+        const memDb = (0, test_utils_1.createTestDb)();
+        const tables = memDb
+            .prepare("SELECT sql FROM sqlite_master WHERE type='table'")
+            .all();
+        for (const t of tables) {
+            db.exec(t.sql + ";");
+        }
+        memDb.close();
+        if (setup)
+            setup(db);
+        db.close();
+    }
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ophan-import-test-"));
+        dbPath = path.join(tmpDir, "index.db");
+    });
+    (0, vitest_1.afterEach)(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("imports new analysis rows", () => {
+        setupDb();
+        const count = (0, index_1.importAnalysis)(dbPath, [
+            {
+                content_hash: "abc",
+                analysis_type: "documentation",
+                analysis: (0, test_utils_1.makeDocAnalysisJson)(),
+                model_version: "test",
+                schema_version: 1,
+                language: "typescript",
+                entity_type: "function",
+            },
+        ]);
+        (0, vitest_1.expect)(count).toBe(1);
+        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        const row = db
+            .prepare("SELECT * FROM function_analysis WHERE content_hash = 'abc'")
+            .get();
+        (0, vitest_1.expect)(row).toBeDefined();
+        (0, vitest_1.expect)(row.analysis_type).toBe("documentation");
+        db.close();
+    });
+    (0, vitest_1.it)("skips existing rows (INSERT OR IGNORE)", () => {
+        setupDb((db) => {
+            (0, test_utils_1.insertAnalysisPair)(db, "exists");
+        });
+        const count = (0, index_1.importAnalysis)(dbPath, [
+            {
+                content_hash: "exists",
+                analysis_type: "documentation",
+                analysis: (0, test_utils_1.makeDocAnalysisJson)({ description: "SHOULD NOT OVERWRITE" }),
+                model_version: "test",
+                schema_version: 1,
+                language: "typescript",
+                entity_type: "function",
+            },
+        ]);
+        (0, vitest_1.expect)(count).toBe(0);
+        // Verify original data unchanged
+        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        const row = db
+            .prepare("SELECT analysis FROM function_analysis WHERE content_hash = 'exists' AND analysis_type = 'documentation'")
+            .get();
+        const parsed = JSON.parse(row.analysis);
+        (0, vitest_1.expect)(parsed.description).toBe("Test function description");
+        db.close();
+    });
+    (0, vitest_1.it)("sets synced_at on imported rows", () => {
+        setupDb();
+        (0, index_1.importAnalysis)(dbPath, [
+            {
+                content_hash: "new1",
+                analysis_type: "security",
+                analysis: (0, test_utils_1.makeSecAnalysisJson)(),
+                model_version: "test",
+                schema_version: 1,
+                language: "typescript",
+                entity_type: "function",
+            },
+        ]);
+        const db = new better_sqlite3_1.default(dbPath, { readonly: true });
+        const row = db
+            .prepare("SELECT synced_at FROM function_analysis WHERE content_hash = 'new1'")
+            .get();
+        (0, vitest_1.expect)(row.synced_at).not.toBeNull();
+        db.close();
+    });
+    (0, vitest_1.it)("returns 0 for empty rows array", () => {
+        setupDb();
+        (0, vitest_1.expect)((0, index_1.importAnalysis)(dbPath, [])).toBe(0);
+    });
+    (0, vitest_1.it)("handles mixed new and existing rows", () => {
+        setupDb((db) => {
+            (0, test_utils_1.insertAnalysisPair)(db, "exists");
+        });
+        const count = (0, index_1.importAnalysis)(dbPath, [
+            {
+                content_hash: "exists",
+                analysis_type: "documentation",
+                analysis: (0, test_utils_1.makeDocAnalysisJson)(),
+                model_version: "test",
+                schema_version: 1,
+                language: "typescript",
+                entity_type: "function",
+            },
+            {
+                content_hash: "new1",
+                analysis_type: "documentation",
+                analysis: (0, test_utils_1.makeDocAnalysisJson)(),
+                model_version: "test",
+                schema_version: 1,
+                language: "typescript",
+                entity_type: "function",
+            },
+            {
+                content_hash: "new2",
+                analysis_type: "security",
+                analysis: (0, test_utils_1.makeSecAnalysisJson)(),
+                model_version: "test",
+                schema_version: 1,
+                language: "python",
+                entity_type: "method",
+            },
+        ]);
+        (0, vitest_1.expect)(count).toBe(2);
+    });
+});
+// ============ findMissingHashes ============
+(0, vitest_1.describe)("findMissingHashes", () => {
+    let tmpDir;
+    let dbPath;
+    function setupDb(setup) {
+        const db = new better_sqlite3_1.default(dbPath);
+        const memDb = (0, test_utils_1.createTestDb)();
+        const tables = memDb
+            .prepare("SELECT sql FROM sqlite_master WHERE type='table'")
+            .all();
+        for (const t of tables) {
+            db.exec(t.sql + ";");
+        }
+        memDb.close();
+        setup(db);
+        db.close();
+    }
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ophan-missing-test-"));
+        dbPath = path.join(tmpDir, "index.db");
+    });
+    (0, vitest_1.afterEach)(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("returns hashes in file_functions but not in function_analysis", () => {
+        setupDb((db) => {
+            (0, test_utils_1.insertFileFunction)(db, "/src/foo.ts", "foo", "hash1");
+            (0, test_utils_1.insertFileFunction)(db, "/src/bar.ts", "bar", "hash2");
+            // Only hash1 has analysis
+            (0, test_utils_1.insertAnalysisPair)(db, "hash1");
+        });
+        const missing = (0, index_1.findMissingHashes)(dbPath);
+        (0, vitest_1.expect)(missing).toEqual(["hash2"]);
+    });
+    (0, vitest_1.it)("returns empty when all hashes are analyzed", () => {
+        setupDb((db) => {
+            (0, test_utils_1.insertFileFunction)(db, "/src/foo.ts", "foo", "hash1");
+            (0, test_utils_1.insertAnalysisPair)(db, "hash1");
+        });
+        const missing = (0, index_1.findMissingHashes)(dbPath);
+        (0, vitest_1.expect)(missing).toEqual([]);
+    });
+    (0, vitest_1.it)("deduplicates — same hash in multiple files returned once", () => {
+        setupDb((db) => {
+            (0, test_utils_1.insertFileFunction)(db, "/src/a.ts", "fn", "shared_hash");
+            (0, test_utils_1.insertFileFunction)(db, "/src/b.ts", "fn", "shared_hash");
+        });
+        const missing = (0, index_1.findMissingHashes)(dbPath);
+        (0, vitest_1.expect)(missing).toEqual(["shared_hash"]);
+    });
+});

package/dist/parsers/__fixtures__/arrow-functions.d.ts

@@ -0,0 +1,5 @@
+export declare const greet: (name: string) => string;
+export declare const add: (a: number, b: number) => number;
+declare const _default: (x: number) => number;
+export default _default;
+//# sourceMappingURL=arrow-functions.d.ts.map

package/dist/parsers/__fixtures__/arrow-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-functions.d.ts","sourceRoot":"","sources":["../../../src/parsers/__fixtures__/arrow-functions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,MAEpC,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,WAAU,CAAC;yBAOnC,GAAG,MAAM;AAAzB,wBAAoC"}

package/dist/parsers/__fixtures__/arrow-functions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = exports.greet = void 0;
+const greet = (name) => {
+    return `Hello, ${name}`;
+};
+exports.greet = greet;
+const add = (a, b) => a + b;
+exports.add = add;
+let handler = (req) => {
+    return req.toUpperCase();
+};
+// Unnamed default export arrow — should be skipped
+exports.default = (x) => x * 2;
+// Callback arrow — should be skipped (no variable declaration parent)
+const results = [1, 2, 3].map((n) => n * 2);

package/dist/parsers/__fixtures__/class-methods.d.ts

@@ -0,0 +1,6 @@
+declare class UserService {
+    getUser(id: string): string;
+    createUser(data: any): Promise<any>;
+}
+declare function standalone(): boolean;
+//# sourceMappingURL=class-methods.d.ts.map

package/dist/parsers/__fixtures__/class-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-methods.d.ts","sourceRoot":"","sources":["../../../src/parsers/__fixtures__/class-methods.ts"],"names":[],"mappings":"AAAA,cAAM,WAAW;IACf,OAAO,CAAC,EAAE,EAAE,MAAM;IAIZ,UAAU,CAAC,IAAI,EAAE,GAAG;CAG3B;AAED,iBAAS,UAAU,YAElB"}

package/dist/parsers/__fixtures__/class-methods.js

@@ -0,0 +1,12 @@
+"use strict";
+class UserService {
+    getUser(id) {
+        return id;
+    }
+    async createUser(data) {
+        return data;
+    }
+}
+function standalone() {
+    return true;
+}

package/dist/parsers/__fixtures__/no-functions.d.ts

@@ -0,0 +1,9 @@
+export type Config = {
+    apiKey: string;
+    baseUrl: string;
+};
+export declare const DEFAULT_TIMEOUT = 5000;
+export interface Options {
+    retry: boolean;
+}
+//# sourceMappingURL=no-functions.d.ts.map

package/dist/parsers/__fixtures__/no-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-functions.d.ts","sourceRoot":"","sources":["../../../src/parsers/__fixtures__/no-functions.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,OAAO,CAAC;CAChB"}

package/dist/parsers/__fixtures__/no-functions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TIMEOUT = void 0;
+exports.DEFAULT_TIMEOUT = 5000;

package/dist/parsers/index.d.ts

@@ -0,0 +1,3 @@
+export type { LanguageParser } from "./types";
+export { getParserForFile, getSupportedExtensions, getRegisteredParsers } from "./registry";
+//# sourceMappingURL=index.d.ts.map

package/dist/parsers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parsers/index.ts"],"names":[],"mappings":"AAcA,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}

package/dist/parsers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+// Parser barrel export — auto-registers all language parsers
+//
+// Importing this module registers all available parsers. To add a new language:
+// 1. Create a parser file in this directory implementing LanguageParser
+// 2. Import and register it below
+// That's it — analyzeRepository() and refreshFileIndex() pick it up automatically.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegisteredParsers = exports.getSupportedExtensions = exports.getParserForFile = void 0;
+const registry_1 = require("./registry");
+const typescript_1 = require("./typescript");
+const python_1 = require("./python");
+(0, registry_1.registerParser)(new typescript_1.TypeScriptParser());
+(0, registry_1.registerParser)(new python_1.PythonParser());
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "getParserForFile", { enumerable: true, get: function () { return registry_2.getParserForFile; } });
+Object.defineProperty(exports, "getSupportedExtensions", { enumerable: true, get: function () { return registry_2.getSupportedExtensions; } });
+Object.defineProperty(exports, "getRegisteredParsers", { enumerable: true, get: function () { return registry_2.getRegisteredParsers; } });

package/dist/parsers/python.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionInfo } from "../shared";
+import type { LanguageParser } from "./types";
+export declare class PythonParser implements LanguageParser {
+    readonly language = "python";
+    readonly extensions: string[];
+    extractFunctions(filePath: string): FunctionInfo[];
+}
+//# sourceMappingURL=python.d.ts.map

package/dist/parsers/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../src/parsers/python.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA0D9C,qBAAa,YAAa,YAAW,cAAc;IACjD,QAAQ,CAAC,QAAQ,YAAY;IAC7B,QAAQ,CAAC,UAAU,WAAW;IAE9B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE;CA+BnD"}