@ophan/core 0.0.2 → 0.0.4

package/dist/migrations.d.ts

@@ -0,0 +1,25 @@
+import type Database from "better-sqlite3";
+export interface Migration {
+    id: string;
+    up: (db: Database.Database) => void;
+}
+/**
+ * Run pending migrations in order. Each migration runs in a transaction —
+ * if it fails, the transaction rolls back and the migration is NOT recorded.
+ * Returns the list of newly applied migration IDs.
+ */
+export declare function runMigrations(db: Database.Database, migrations: Migration[], appliedBy: string): string[];
+/**
+ * Record all migrations as applied WITHOUT running them.
+ * Used when creating a fresh DB with createFreshSchema() — the schema
+ * is already at the latest state, so migrations don't need to run.
+ */
+export declare function bootstrapMigrations(db: Database.Database, migrations: Migration[], appliedBy: string): void;
+export declare const CORE_MIGRATIONS: Migration[];
+/**
+ * Migrate from single-blob function_analysis to split analysis types.
+ * Called from core_002_analysis_types migration on databases that predate
+ * the analysis_type column. Exported for testing.
+ */
+export declare function migrateToAnalysisTypes(db: Database.Database): void;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../src/migrations.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAC;CACrC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,UAAU,EAAE,SAAS,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,MAAM,EAAE,CAgCV;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,UAAU,EAAE,SAAS,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,IAAI,CAgBN;AAcD,eAAO,MAAM,eAAe,EAAE,SAAS,EAkLtC,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,QA8D3D"}

package/dist/migrations.js

@@ -0,0 +1,323 @@
+"use strict";
+// Migration runner for @ophan/core.
+//
+// Mirrors the extension's migration runner (packages/vscode/src/migrations.ts).
+// Both share the _ophan_migrations table format but maintain independent
+// migration lists — core prefixes with "core_", extension with "ext_".
+//
+// Each migration is idempotent (uses IF NOT EXISTS, try-catch for ADD COLUMN)
+// and runs in a transaction.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_MIGRATIONS = void 0;
+exports.runMigrations = runMigrations;
+exports.bootstrapMigrations = bootstrapMigrations;
+exports.migrateToAnalysisTypes = migrateToAnalysisTypes;
+/**
+ * Run pending migrations in order. Each migration runs in a transaction —
+ * if it fails, the transaction rolls back and the migration is NOT recorded.
+ * Returns the list of newly applied migration IDs.
+ */
+function runMigrations(db, migrations, appliedBy) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS _ophan_migrations (
+      migration_id TEXT PRIMARY KEY,
+      applied_at INTEGER NOT NULL,
+      applied_by TEXT NOT NULL
+    )
+  `);
+    const applied = new Set(db.prepare("SELECT migration_id FROM _ophan_migrations").all().map((r) => r.migration_id));
+    const ran = [];
+    const insert = db.prepare("INSERT INTO _ophan_migrations (migration_id, applied_at, applied_by) VALUES (?, ?, ?)");
+    for (const m of migrations) {
+        if (applied.has(m.id))
+            continue;
+        db.transaction(() => {
+            m.up(db);
+            insert.run(m.id, Date.now(), appliedBy);
+        })();
+        ran.push(m.id);
+    }
+    return ran;
+}
+/**
+ * Record all migrations as applied WITHOUT running them.
+ * Used when creating a fresh DB with createFreshSchema() — the schema
+ * is already at the latest state, so migrations don't need to run.
+ */
+function bootstrapMigrations(db, migrations, appliedBy) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS _ophan_migrations (
+      migration_id TEXT PRIMARY KEY,
+      applied_at INTEGER NOT NULL,
+      applied_by TEXT NOT NULL
+    )
+  `);
+    const insert = db.prepare("INSERT OR IGNORE INTO _ophan_migrations (migration_id, applied_at, applied_by) VALUES (?, ?, ?)");
+    const now = Date.now();
+    for (const m of migrations) {
+        insert.run(m.id, now, appliedBy);
+    }
+}
+// ============ CORE MIGRATIONS ============
+//
+// These run on existing databases to bring them up to the current schema.
+// For fresh databases, createFreshSchema() creates the latest schema directly
+// and bootstrapMigrations() records all of these as applied.
+//
+// RULES:
+// 1. Migrations are immutable — once shipped, never modify. Fix forward.
+// 2. Migrations are idempotent — safe to run twice (IF NOT EXISTS, try-catch).
+// 3. Each runs in a transaction — rolls back on failure.
+// 4. Never rename tables or columns — add new, deprecate old.
+exports.CORE_MIGRATIONS = [
+    {
+        id: "core_001_fresh_schema",
+        up: (db) => {
+            // Base tables — CREATE IF NOT EXISTS is a no-op on existing DBs
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS function_analysis (
+          content_hash TEXT NOT NULL,
+          analysis_type TEXT NOT NULL,
+          analysis JSON NOT NULL,
+          model_version TEXT NOT NULL,
+          schema_version INTEGER NOT NULL DEFAULT 1,
+          created_at INTEGER NOT NULL,
+          last_seen_at INTEGER NOT NULL,
+          language TEXT NOT NULL DEFAULT 'typescript',
+          entity_type TEXT NOT NULL DEFAULT 'function',
+          synced_at INTEGER,
+          PRIMARY KEY (content_hash, analysis_type)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS file_functions (
+          file_path TEXT NOT NULL,
+          function_name TEXT NOT NULL,
+          content_hash TEXT NOT NULL,
+          file_mtime INTEGER NOT NULL,
+          language TEXT NOT NULL DEFAULT 'typescript',
+          entity_type TEXT NOT NULL DEFAULT 'function',
+          start_line INTEGER NOT NULL DEFAULT 0,
+          PRIMARY KEY (file_path, function_name)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS function_gc (
+          content_hash TEXT NOT NULL,
+          analysis_type TEXT,
+          gc_at INTEGER NOT NULL,
+          synced_at INTEGER,
+          PRIMARY KEY (content_hash, analysis_type)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS sync_meta (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        )
+      `);
+        },
+    },
+    {
+        id: "core_002_analysis_types",
+        up: (db) => {
+            // Detect if we need the monolithic→typed migration by checking for analysis_type column
+            const columns = db
+                .prepare("PRAGMA table_info(function_analysis)")
+                .all();
+            if (columns.length > 0 && !columns.some((c) => c.name === "analysis_type")) {
+                // Import the migration function — it handles the full transform
+                // This is the only migration that needs the complex table replacement logic
+                migrateToAnalysisTypes(db);
+            }
+        },
+    },
+    {
+        id: "core_003_file_functions_columns",
+        up: (db) => {
+            const cols = db
+                .prepare("PRAGMA table_info(file_functions)")
+                .all();
+            if (!cols.some((c) => c.name === "language")) {
+                try {
+                    db.exec("ALTER TABLE file_functions ADD COLUMN language TEXT NOT NULL DEFAULT 'typescript'");
+                }
+                catch (_) { }
+                try {
+                    db.exec("ALTER TABLE file_functions ADD COLUMN entity_type TEXT NOT NULL DEFAULT 'function'");
+                }
+                catch (_) { }
+            }
+            if (!cols.some((c) => c.name === "start_line")) {
+                try {
+                    db.exec("ALTER TABLE file_functions ADD COLUMN start_line INTEGER NOT NULL DEFAULT 0");
+                }
+                catch (_) { }
+            }
+        },
+    },
+    {
+        id: "core_004_gc_analysis_type",
+        up: (db) => {
+            const cols = db
+                .prepare("PRAGMA table_info(function_gc)")
+                .all();
+            if (!cols.some((c) => c.name === "analysis_type")) {
+                try {
+                    db.exec("ALTER TABLE function_gc ADD COLUMN analysis_type TEXT");
+                }
+                catch (_) { }
+                // Rebuild PK by recreating table
+                db.exec(`
+          CREATE TABLE IF NOT EXISTS function_gc_v2 (
+            content_hash TEXT NOT NULL,
+            analysis_type TEXT,
+            gc_at INTEGER NOT NULL,
+            synced_at INTEGER,
+            PRIMARY KEY (content_hash, analysis_type)
+          )
+        `);
+                db.exec("INSERT OR IGNORE INTO function_gc_v2 SELECT content_hash, NULL, gc_at, synced_at FROM function_gc");
+                db.exec("DROP TABLE function_gc");
+                db.exec("ALTER TABLE function_gc_v2 RENAME TO function_gc");
+            }
+        },
+    },
+    {
+        id: "core_005_graph_tables",
+        up: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS function_edges (
+          source_hash TEXT NOT NULL,
+          target_hash TEXT NOT NULL,
+          edge_type TEXT NOT NULL,
+          weight REAL NOT NULL DEFAULT 1.0,
+          PRIMARY KEY (source_hash, target_hash, edge_type)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS communities (
+          content_hash TEXT NOT NULL,
+          level INTEGER NOT NULL,
+          community_id TEXT NOT NULL,
+          algorithm TEXT NOT NULL DEFAULT 'louvain',
+          PRIMARY KEY (content_hash, level, algorithm)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS community_summaries (
+          community_id TEXT NOT NULL,
+          level INTEGER NOT NULL,
+          algorithm TEXT NOT NULL DEFAULT 'louvain',
+          input_hash TEXT NOT NULL,
+          summary JSON NOT NULL,
+          model_version TEXT,
+          created_at INTEGER NOT NULL,
+          PRIMARY KEY (community_id, level, algorithm)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS graph_config (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS community_edges (
+          source_community TEXT NOT NULL,
+          target_community TEXT NOT NULL,
+          algorithm TEXT NOT NULL DEFAULT 'louvain',
+          weight REAL NOT NULL DEFAULT 0,
+          edge_count INTEGER NOT NULL DEFAULT 0,
+          PRIMARY KEY (source_community, target_community, algorithm)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS community_signatures (
+          community_id TEXT NOT NULL,
+          algorithm TEXT NOT NULL DEFAULT 'louvain',
+          signatures JSON NOT NULL,
+          PRIMARY KEY (community_id, algorithm)
+        )
+      `);
+        },
+    },
+    {
+        id: "core_006_practices_table",
+        up: (db) => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS practices (
+          practice_id TEXT PRIMARY KEY,
+          rule TEXT NOT NULL,
+          severity TEXT NOT NULL DEFAULT 'warning'
+        )
+      `);
+        },
+    },
+];
+// ============ LEGACY MIGRATION HELPER ============
+/**
+ * Migrate from single-blob function_analysis to split analysis types.
+ * Called from core_002_analysis_types migration on databases that predate
+ * the analysis_type column. Exported for testing.
+ */
+function migrateToAnalysisTypes(db) {
+    db.exec(`
+    CREATE TABLE function_analysis_v2 (
+      content_hash TEXT NOT NULL,
+      analysis_type TEXT NOT NULL,
+      analysis JSON NOT NULL,
+      model_version TEXT NOT NULL,
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      created_at INTEGER NOT NULL,
+      last_seen_at INTEGER NOT NULL,
+      language TEXT NOT NULL DEFAULT 'typescript',
+      entity_type TEXT NOT NULL DEFAULT 'function',
+      synced_at INTEGER,
+      PRIMARY KEY (content_hash, analysis_type)
+    )
+  `);
+    // Split documentation fields
+    db.exec(`
+    INSERT OR IGNORE INTO function_analysis_v2
+      (content_hash, analysis_type, analysis, model_version, schema_version, created_at, last_seen_at, language, entity_type, synced_at)
+    SELECT
+      content_hash,
+      'documentation',
+      json_object(
+        'description', json_extract(analysis, '$.description'),
+        'params', json_extract(analysis, '$.params'),
+        'returns', json_extract(analysis, '$.returns')
+      ),
+      model_version,
+      1,
+      created_at,
+      last_seen_at,
+      COALESCE(language, 'typescript'),
+      COALESCE(entity_type, 'function'),
+      NULL
+    FROM function_analysis
+  `);
+    // Split security fields
+    db.exec(`
+    INSERT OR IGNORE INTO function_analysis_v2
+      (content_hash, analysis_type, analysis, model_version, schema_version, created_at, last_seen_at, language, entity_type, synced_at)
+    SELECT
+      content_hash,
+      'security',
+      json_object(
+        'dataTags', json_extract(analysis, '$.dataTags'),
+        'securityFlags', json_extract(analysis, '$.securityFlags')
+      ),
+      model_version,
+      1,
+      created_at,
+      last_seen_at,
+      COALESCE(language, 'typescript'),
+      COALESCE(entity_type, 'function'),
+      NULL
+    FROM function_analysis
+  `);
+    db.exec("DROP TABLE function_analysis");
+    db.exec("ALTER TABLE function_analysis_v2 RENAME TO function_analysis");
+}

package/dist/module-resolvers/index.d.ts

@@ -0,0 +1,11 @@
+export type { LanguageModuleResolver } from "./types";
+export { JavaScriptModuleResolver } from "./javascript";
+import type { LanguageModuleResolver } from "./types";
+export declare function registerModuleResolver(resolver: LanguageModuleResolver): void;
+export declare function getModuleResolver(language: string): LanguageModuleResolver | undefined;
+/**
+ * Find the module resolver that handles a given file path,
+ * matched by file extension against resolver.extensions.
+ */
+export declare function getModuleResolverForFile(filePath: string): LanguageModuleResolver | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/module-resolvers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/module-resolvers/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAMtD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI,CAE7E;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,GACf,sBAAsB,GAAG,SAAS,CAEpC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,GACf,sBAAsB,GAAG,SAAS,CAMpC"}

package/dist/module-resolvers/index.js

@@ -0,0 +1,67 @@
+"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.JavaScriptModuleResolver = void 0;
+exports.registerModuleResolver = registerModuleResolver;
+exports.getModuleResolver = getModuleResolver;
+exports.getModuleResolverForFile = getModuleResolverForFile;
+var javascript_1 = require("./javascript");
+Object.defineProperty(exports, "JavaScriptModuleResolver", { enumerable: true, get: function () { return javascript_1.JavaScriptModuleResolver; } });
+const javascript_2 = require("./javascript");
+const path = __importStar(require("path"));
+const registry = new Map();
+function registerModuleResolver(resolver) {
+    registry.set(resolver.language, resolver);
+}
+function getModuleResolver(language) {
+    return registry.get(language);
+}
+/**
+ * Find the module resolver that handles a given file path,
+ * matched by file extension against resolver.extensions.
+ */
+function getModuleResolverForFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    for (const resolver of registry.values()) {
+        if (resolver.extensions.includes(ext))
+            return resolver;
+    }
+    return undefined;
+}
+// Register built-in resolvers
+const jsResolver = new javascript_2.JavaScriptModuleResolver();
+registerModuleResolver(jsResolver);
+// Also register under "javascript" alias
+registry.set("javascript", jsResolver);

package/dist/module-resolvers/javascript.d.ts

@@ -0,0 +1,18 @@
+import type { LanguageModuleResolver } from "./types";
+import type { ModuleResolver } from "../graph";
+/**
+ * Module resolution for JavaScript/TypeScript ecosystems.
+ * Handles relative imports, workspace packages (via package.json exports),
+ * and path aliases (via tsconfig.json paths).
+ */
+export declare class JavaScriptModuleResolver implements LanguageModuleResolver {
+    readonly language = "typescript";
+    readonly extensions: readonly [".ts", ".tsx", ".js", ".jsx"];
+    /**
+     * Try resolving a base path to an actual file, probing JS/TS extensions
+     * and index file patterns.
+     */
+    private tryResolveWithExtensions;
+    resolveModuleToFile(importModule: string, importerFilePath: string, fileToHashes: Map<string, Set<string>>, resolver?: ModuleResolver): string | undefined;
+}
+//# sourceMappingURL=javascript.d.ts.map

package/dist/module-resolvers/javascript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../src/module-resolvers/javascript.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;GAIG;AACH,qBAAa,wBAAyB,YAAW,sBAAsB;IACrE,QAAQ,CAAC,QAAQ,gBAAgB;IACjC,QAAQ,CAAC,UAAU,0CAA2C;IAE9D;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAoBhC,mBAAmB,CACjB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EACtC,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,GAAG,SAAS;CAoEtB"}

package/dist/module-resolvers/javascript.js

@@ -0,0 +1,130 @@
+"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.JavaScriptModuleResolver = void 0;
+const path = __importStar(require("path"));
+/**
+ * Module resolution for JavaScript/TypeScript ecosystems.
+ * Handles relative imports, workspace packages (via package.json exports),
+ * and path aliases (via tsconfig.json paths).
+ */
+class JavaScriptModuleResolver {
+    constructor() {
+        this.language = "typescript";
+        this.extensions = [".ts", ".tsx", ".js", ".jsx"];
+    }
+    /**
+     * Try resolving a base path to an actual file, probing JS/TS extensions
+     * and index file patterns.
+     */
+    tryResolveWithExtensions(resolvedBase, fileToHashes) {
+        for (const candidate of [
+            resolvedBase,
+            resolvedBase + ".ts",
+            resolvedBase + ".tsx",
+            resolvedBase + ".js",
+            resolvedBase + ".jsx",
+            resolvedBase + ".py",
+        ]) {
+            if (fileToHashes.has(candidate))
+                return candidate;
+        }
+        for (const idx of ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"]) {
+            if (fileToHashes.has(resolvedBase + idx))
+                return resolvedBase + idx;
+        }
+        return undefined;
+    }
+    resolveModuleToFile(importModule, importerFilePath, fileToHashes, resolver) {
+        // Case 1: Relative imports
+        if (importModule.startsWith("./") || importModule.startsWith("../")) {
+            const resolvedBase = path.resolve(path.dirname(importerFilePath), importModule);
+            return this.tryResolveWithExtensions(resolvedBase, fileToHashes);
+        }
+        if (!resolver)
+            return undefined;
+        // Case 2: Workspace package imports (e.g. "@ophan/core/schemas")
+        for (const [pkgName, pkg] of resolver.workspacePackages) {
+            if (importModule === pkgName || importModule.startsWith(pkgName + "/")) {
+                const subpath = importModule === pkgName
+                    ? "."
+                    : "./" + importModule.slice(pkgName.length + 1);
+                // Look up in exports map
+                const exportTarget = pkg.exports[subpath];
+                if (exportTarget) {
+                    const resolved = path.resolve(pkg.dir, exportTarget);
+                    return this.tryResolveWithExtensions(resolved, fileToHashes);
+                }
+                // Fallback: conventional src/ resolution
+                if (subpath === ".") {
+                    return this.tryResolveWithExtensions(path.resolve(pkg.dir, "src/index"), fileToHashes);
+                }
+                else {
+                    const srcFile = path.resolve(pkg.dir, "src", subpath.slice(2));
+                    return this.tryResolveWithExtensions(srcFile, fileToHashes);
+                }
+            }
+        }
+        // Case 3: Path alias imports (e.g. "@/components/ui/button")
+        for (const [pkgDir, aliases] of resolver.pathAliases) {
+            if (!importerFilePath.startsWith(pkgDir + "/"))
+                continue;
+            for (const [aliasPattern, targets] of Object.entries(aliases.paths)) {
+                const hasStar = aliasPattern.endsWith("/*");
+                const prefix = hasStar ? aliasPattern.slice(0, -1) : aliasPattern;
+                if (hasStar && importModule.startsWith(prefix)) {
+                    const remainder = importModule.slice(prefix.length);
+                    for (const targetPattern of targets) {
+                        const targetBase = targetPattern.replace("/*", "/" + remainder);
+                        const resolved = path.resolve(aliases.baseUrl, targetBase);
+                        const result = this.tryResolveWithExtensions(resolved, fileToHashes);
+                        if (result)
+                            return result;
+                    }
+                }
+                else if (!hasStar && importModule === aliasPattern) {
+                    for (const targetPattern of targets) {
+                        const resolved = path.resolve(aliases.baseUrl, targetPattern);
+                        const result = this.tryResolveWithExtensions(resolved, fileToHashes);
+                        if (result)
+                            return result;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+}
+exports.JavaScriptModuleResolver = JavaScriptModuleResolver;

package/dist/module-resolvers/types.d.ts

@@ -0,0 +1,18 @@
+import type { ModuleResolver } from "../graph";
+/**
+ * Strategy interface for language-specific module resolution.
+ * Each implementation handles import specifier → file path resolution
+ * for one language ecosystem (JS/TS, Python, Go, etc.).
+ */
+export interface LanguageModuleResolver {
+    /** Language identifier (e.g., "typescript", "python") */
+    readonly language: string;
+    /** File extensions this resolver handles (e.g., [".ts", ".tsx", ".js", ".jsx"]) */
+    readonly extensions: readonly string[];
+    /**
+     * Resolve an import module specifier to an absolute file path.
+     * Returns undefined if the specifier can't be resolved.
+     */
+    resolveModuleToFile(importModule: string, importerFilePath: string, fileToHashes: Map<string, Set<string>>, workspaceResolver?: ModuleResolver): string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/module-resolvers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/module-resolvers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mFAAmF;IACnF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;OAGG;IACH,mBAAmB,CACjB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EACtC,iBAAiB,CAAC,EAAE,cAAc,GACjC,MAAM,GAAG,SAAS,CAAC;CACvB"}

package/dist/module-resolvers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1 +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"}
+{"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;AAiG9C,qBAAa,YAAa,YAAW,cAAc;IACjD,QAAQ,CAAC,QAAQ,YAAY;IAC7B,QAAQ,CAAC,UAAU,WAAW;IAE9B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE;CAsCnD"}