@ophan/core 0.0.1

package/dist/parsers/python.js

@@ -0,0 +1,137 @@
+"use strict";
+// Python parser — uses Python's own ast module via python3 subprocess
+//
+// Zero npm dependencies. Shells out to `python3 -c "..."` with an inline script that uses
+// Python's built-in ast module to extract functions, async functions, and class methods.
+// The script outputs JSON to stdout which we parse in Node.js.
+//
+// If python3 is not installed, the parser logs a warning and returns empty results.
+// This means Python files are simply skipped during analysis — TypeScript analysis
+// continues working regardless.
+//
+// Why not a JS-based Python parser?
+//   - Python's ast module is the canonical parser, maintained by CPython itself
+//   - It handles all Python syntax perfectly (decorators, async, walrus operator, etc.)
+//   - Zero maintenance burden — ast evolves with Python
+//   - The subprocess call adds ~50ms per file, acceptable for batch analysis
+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.PythonParser = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const shared_1 = require("../shared");
+// Inline Python script that extracts function info using the ast module.
+// Outputs JSON array to stdout. Uses parent tracking to detect methods vs functions.
+const PYTHON_EXTRACT_SCRIPT = `
+import ast, json, sys
+
+source = sys.stdin.read()
+tree = ast.parse(source)
+
+# Annotate parent references so we can detect methods (FunctionDef inside ClassDef)
+for node in ast.walk(tree):
+    for child in ast.iter_child_nodes(node):
+        child._parent = node
+
+functions = []
+lines = source.split('\\n')
+
+for node in ast.walk(tree):
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        end_line = getattr(node, 'end_lineno', None) or node.lineno
+        source_code = '\\n'.join(lines[node.lineno - 1 : end_line])
+
+        parent = getattr(node, '_parent', None)
+        entity_type = "method" if isinstance(parent, ast.ClassDef) else "function"
+
+        functions.append({
+            "name": node.name,
+            "startLine": node.lineno,
+            "endLine": end_line,
+            "sourceCode": source_code,
+            "entityType": entity_type
+        })
+
+json.dump(functions, sys.stdout)
+`;
+let pythonAvailable = null;
+function isPythonAvailable() {
+    if (pythonAvailable !== null)
+        return pythonAvailable;
+    try {
+        (0, child_process_1.execFileSync)("python3", ["--version"], { stdio: "ignore" });
+        pythonAvailable = true;
+    }
+    catch {
+        pythonAvailable = false;
+    }
+    return pythonAvailable;
+}
+class PythonParser {
+    constructor() {
+        this.language = "python";
+        this.extensions = [".py"];
+    }
+    extractFunctions(filePath) {
+        if (!isPythonAvailable()) {
+            console.warn("python3 not found — skipping Python files. Install Python 3 to enable Python analysis.");
+            return [];
+        }
+        try {
+            const source = fs.readFileSync(filePath, "utf-8");
+            const output = (0, child_process_1.execFileSync)("python3", ["-c", PYTHON_EXTRACT_SCRIPT], {
+                input: source,
+                encoding: "utf-8",
+                timeout: 10000, // 10s timeout per file
+            });
+            const raw = JSON.parse(output);
+            return raw.map((fn) => ({
+                name: fn.name,
+                filePath,
+                startLine: fn.startLine,
+                endLine: fn.endLine,
+                sourceCode: fn.sourceCode,
+                contentHash: (0, shared_1.computeHash)(fn.sourceCode),
+                language: "python",
+                entityType: fn.entityType,
+            }));
+        }
+        catch (err) {
+            console.error(`Failed to parse Python file ${filePath}:`, err.message);
+            return [];
+        }
+    }
+}
+exports.PythonParser = PythonParser;

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

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

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

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

package/dist/parsers/python.test.js

@@ -0,0 +1,96 @@
+"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 });
+const vitest_1 = require("vitest");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const python_1 = require("./python");
+const parser = new python_1.PythonParser();
+const fixturesDir = path.join(__dirname, "__fixtures__");
+// Must be synchronous at module level — describe.skipIf evaluates immediately
+let pythonAvailable = false;
+try {
+    (0, child_process_1.execFileSync)("python3", ["--version"], { stdio: "ignore" });
+    pythonAvailable = true;
+}
+catch {
+    pythonAvailable = false;
+}
+(0, vitest_1.describe)("PythonParser", () => {
+    vitest_1.describe.skipIf(!pythonAvailable)("method detection", () => {
+        (0, vitest_1.it)('class methods get entityType "method"', () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "class-methods.py"));
+            const getUser = functions.find((f) => f.name === "get_user");
+            const createUser = functions.find((f) => f.name === "create_user");
+            (0, vitest_1.expect)(getUser?.entityType).toBe("method");
+            (0, vitest_1.expect)(createUser?.entityType).toBe("method");
+        });
+        (0, vitest_1.it)('top-level functions get entityType "function"', () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "class-methods.py"));
+            const standalone = functions.find((f) => f.name === "standalone");
+            (0, vitest_1.expect)(standalone?.entityType).toBe("function");
+        });
+    });
+    vitest_1.describe.skipIf(!pythonAvailable)("async function handling", () => {
+        (0, vitest_1.it)("extracts async def functions", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "simple.py"));
+            const fetchData = functions.find((f) => f.name === "fetch_data");
+            (0, vitest_1.expect)(fetchData).toBeDefined();
+            (0, vitest_1.expect)(fetchData?.language).toBe("python");
+        });
+    });
+    vitest_1.describe.skipIf(!pythonAvailable)("basic extraction", () => {
+        (0, vitest_1.it)("extracts all functions from simple file", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "simple.py"));
+            const names = functions.map((f) => f.name);
+            (0, vitest_1.expect)(names).toContain("greet");
+            (0, vitest_1.expect)(names).toContain("fetch_data");
+            (0, vitest_1.expect)(names).toContain("add");
+        });
+        (0, vitest_1.it)("all extracted functions have contentHash set", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "simple.py"));
+            for (const fn of functions) {
+                (0, vitest_1.expect)(fn.contentHash).toBeDefined();
+                (0, vitest_1.expect)(fn.contentHash.length).toBe(64);
+            }
+        });
+        (0, vitest_1.it)("all functions have language python", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "simple.py"));
+            for (const fn of functions) {
+                (0, vitest_1.expect)(fn.language).toBe("python");
+            }
+        });
+    });
+});

package/dist/parsers/registry.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageParser } from "./types";
+export declare function registerParser(parser: LanguageParser): void;
+export declare function getParserForFile(filePath: string): LanguageParser | null;
+/** Returns all supported file extensions (e.g. [".ts", ".tsx", ".js", ".jsx", ".py"]) */
+export declare function getSupportedExtensions(): string[];
+/** Returns all registered parsers */
+export declare function getRegisteredParsers(): readonly LanguageParser[];
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/parsers/registry.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAQ9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAK3D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAGxE;AAED,yFAAyF;AACzF,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAED,qCAAqC;AACrC,wBAAgB,oBAAoB,IAAI,SAAS,cAAc,EAAE,CAEhE"}

package/dist/parsers/registry.js

@@ -0,0 +1,68 @@
+"use strict";
+// Parser registry — maps file extensions to language parsers
+//
+// The registry is the single lookup point used by analyzeRepository() and refreshFileIndex()
+// to determine which parser handles a given file. Parsers self-register on import via
+// registerParser(), and the glob pattern for file discovery is built dynamically from
+// getSupportedExtensions() so adding a new language automatically includes its files.
+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.registerParser = registerParser;
+exports.getParserForFile = getParserForFile;
+exports.getSupportedExtensions = getSupportedExtensions;
+exports.getRegisteredParsers = getRegisteredParsers;
+const path = __importStar(require("path"));
+/** Maps file extension (e.g. ".ts") to its parser */
+const parsersByExtension = new Map();
+/** All registered parsers for iteration */
+const allParsers = [];
+function registerParser(parser) {
+    allParsers.push(parser);
+    for (const ext of parser.extensions) {
+        parsersByExtension.set(ext.toLowerCase(), parser);
+    }
+}
+function getParserForFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return parsersByExtension.get(ext) || null;
+}
+/** Returns all supported file extensions (e.g. [".ts", ".tsx", ".js", ".jsx", ".py"]) */
+function getSupportedExtensions() {
+    return Array.from(parsersByExtension.keys());
+}
+/** Returns all registered parsers */
+function getRegisteredParsers() {
+    return allParsers;
+}

package/dist/parsers/types.d.ts

@@ -0,0 +1,10 @@
+import type { FunctionInfo } from "../shared";
+export interface LanguageParser {
+    /** Language identifier stored in DB, e.g. "typescript", "python" */
+    readonly language: string;
+    /** File extensions this parser handles, including the dot, e.g. [".ts", ".tsx"] */
+    readonly extensions: string[];
+    /** Extract function-like entities from a source file */
+    extractFunctions(filePath: string): FunctionInfo[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/parsers/types.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;IAE9B,wDAAwD;IACxD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE,CAAC;CACpD"}

package/dist/parsers/types.js

@@ -0,0 +1,18 @@
+"use strict";
+// Parser interface — the abstraction that enables multi-language support
+//
+// Each language implements LanguageParser to extract function-like entities from source files.
+// The interface is deliberately minimal: given a file path, return an array of FunctionInfo.
+//
+// Why not tree-sitter or a custom LSP?
+//   - Tree-sitter adds native C dependencies and grammar management complexity.
+//   - A custom LSP is unnecessary — the CLI + SQLite DB is the cross-IDE abstraction.
+//   - Instead, each parser uses the language's own tooling: TypeScript compiler API for TS/JS,
+//     Python's ast module for Python, go/parser for Go, etc. Zero extra dependencies per language.
+//
+// To add a new language:
+//   1. Create a new file in this directory (e.g., go.ts)
+//   2. Implement LanguageParser with the correct extensions and extractFunctions()
+//   3. Register it in parsers/index.ts
+//   That's it — the analysis pipeline, hashing, DB storage, and sync all work unchanged.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parsers/typescript.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/parsers/typescript.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAa9C,qBAAa,gBAAiB,YAAW,cAAc;IACrD,QAAQ,CAAC,QAAQ,gBAAgB;IACjC,QAAQ,CAAC,UAAU,WAAkC;IAErD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE;CAyDnD"}

package/dist/parsers/typescript.js

@@ -0,0 +1,110 @@
+"use strict";
+// TypeScript/JavaScript parser — uses the TypeScript compiler API
+//
+// Handles .ts, .tsx, .js, .jsx files. The TypeScript compiler can parse JavaScript too,
+// so one parser covers both languages (with correct language labels).
+//
+// The TS compiler API gives us deep understanding of function types: declarations, methods,
+// arrow functions, and function expressions. This is more reliable than regex or tree-sitter
+// for TypeScript specifically, and it's already a dependency.
+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.TypeScriptParser = void 0;
+const ts = __importStar(require("typescript"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const shared_1 = require("../shared");
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".ts" || ext === ".tsx")
+        return "typescript";
+    return "javascript";
+}
+function detectEntityType(node) {
+    if (ts.isMethodDeclaration(node))
+        return "method";
+    return "function";
+}
+class TypeScriptParser {
+    constructor() {
+        this.language = "typescript"; // label for the primary language
+        this.extensions = [".ts", ".tsx", ".js", ".jsx"];
+    }
+    extractFunctions(filePath) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+        const language = detectLanguage(filePath);
+        const functions = [];
+        function visit(node) {
+            if (ts.isFunctionDeclaration(node) ||
+                ts.isMethodDeclaration(node) ||
+                ts.isArrowFunction(node) ||
+                ts.isFunctionExpression(node)) {
+                const name = getFunctionName(node);
+                if (!name)
+                    return;
+                const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+                const sourceCode = node.getText(sourceFile);
+                functions.push({
+                    name,
+                    filePath,
+                    startLine: start.line + 1,
+                    endLine: end.line + 1,
+                    sourceCode,
+                    contentHash: (0, shared_1.computeHash)(sourceCode),
+                    language,
+                    entityType: detectEntityType(node),
+                });
+            }
+            ts.forEachChild(node, visit);
+        }
+        function getFunctionName(node) {
+            if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
+                return node.name?.getText(sourceFile) || null;
+            }
+            if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+                const parent = node.parent;
+                if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+                    return parent.name.getText(sourceFile);
+                }
+            }
+            return null;
+        }
+        visit(sourceFile);
+        return functions;
+    }
+}
+exports.TypeScriptParser = TypeScriptParser;

package/dist/parsers/typescript.test.d.ts

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

package/dist/parsers/typescript.test.d.ts.map

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

package/dist/parsers/typescript.test.js

@@ -0,0 +1,106 @@
+"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 });
+const vitest_1 = require("vitest");
+const path = __importStar(require("path"));
+const typescript_1 = require("./typescript");
+const parser = new typescript_1.TypeScriptParser();
+const fixturesDir = path.join(__dirname, "__fixtures__");
+(0, vitest_1.describe)("TypeScriptParser", () => {
+    (0, vitest_1.describe)("name extraction", () => {
+        (0, vitest_1.it)("extracts name from const arrow function declarations", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "arrow-functions.ts"));
+            const names = functions.map((f) => f.name);
+            (0, vitest_1.expect)(names).toContain("greet");
+            (0, vitest_1.expect)(names).toContain("add");
+            (0, vitest_1.expect)(names).toContain("handler");
+        });
+        (0, vitest_1.it)("skips unnamed default export arrows", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "arrow-functions.ts"));
+            const names = functions.map((f) => f.name);
+            // The default export `(x: number) => x * 2` has no variable declaration parent
+            // so it should not appear in the extracted functions
+            const unnamed = functions.filter((f) => f.name === null || f.name === undefined);
+            (0, vitest_1.expect)(unnamed).toHaveLength(0);
+        });
+        (0, vitest_1.it)("skips callback arrows without variable declaration parent", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "arrow-functions.ts"));
+            const names = functions.map((f) => f.name);
+            // The `(n) => n * 2` inside .map() should not appear
+            // (its parent is a CallExpression argument, not a VariableDeclaration)
+            (0, vitest_1.expect)(names).not.toContain("n");
+        });
+    });
+    (0, vitest_1.describe)("entity type detection", () => {
+        (0, vitest_1.it)('class methods get entityType "method"', () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "class-methods.ts"));
+            const getUser = functions.find((f) => f.name === "getUser");
+            const createUser = functions.find((f) => f.name === "createUser");
+            (0, vitest_1.expect)(getUser?.entityType).toBe("method");
+            (0, vitest_1.expect)(createUser?.entityType).toBe("method");
+        });
+        (0, vitest_1.it)('standalone functions get entityType "function"', () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "class-methods.ts"));
+            const standalone = functions.find((f) => f.name === "standalone");
+            (0, vitest_1.expect)(standalone?.entityType).toBe("function");
+        });
+    });
+    (0, vitest_1.describe)("language detection", () => {
+        (0, vitest_1.it)(".ts files get language typescript", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "class-methods.ts"));
+            for (const fn of functions) {
+                (0, vitest_1.expect)(fn.language).toBe("typescript");
+            }
+        });
+    });
+    (0, vitest_1.describe)("edge cases", () => {
+        (0, vitest_1.it)("file with no functions returns empty array", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "no-functions.ts"));
+            (0, vitest_1.expect)(functions).toEqual([]);
+        });
+        (0, vitest_1.it)("all extracted functions have contentHash set", () => {
+            const functions = parser.extractFunctions(path.join(fixturesDir, "arrow-functions.ts"));
+            for (const fn of functions) {
+                (0, vitest_1.expect)(fn.contentHash).toBeDefined();
+                (0, vitest_1.expect)(fn.contentHash.length).toBe(64); // SHA256 hex
+            }
+        });
+        (0, vitest_1.it)("same source code produces same hash (deterministic)", () => {
+            const fns1 = parser.extractFunctions(path.join(fixturesDir, "class-methods.ts"));
+            const fns2 = parser.extractFunctions(path.join(fixturesDir, "class-methods.ts"));
+            (0, vitest_1.expect)(fns1.map((f) => f.contentHash)).toEqual(fns2.map((f) => f.contentHash));
+        });
+    });
+});