@ophan/core 0.0.2 → 0.0.3

package/dist/edge-resolvers/co-location.d.ts

@@ -0,0 +1,16 @@
+import type { EdgeResolver, EdgeResolverContext } from "./types";
+import type { FunctionEdge } from "../graph";
+/**
+ * Resolves co-location edges — proximity-based connections between functions
+ * in the same file or same directory.
+ *
+ * Same-file: all-pairs with weight decaying by positional distance (1/offset).
+ * Directory (cross-file): half the same-file weight, also decaying by offset.
+ *
+ * Owns a shared dedup Set to prevent duplicate edges across both phases.
+ */
+export declare class CoLocationEdgeResolver implements EdgeResolver {
+    readonly edgeTypes: readonly ["co_location"];
+    resolve(ctx: EdgeResolverContext): FunctionEdge[];
+}
+//# sourceMappingURL=co-location.d.ts.map

package/dist/edge-resolvers/co-location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"co-location.d.ts","sourceRoot":"","sources":["../../src/edge-resolvers/co-location.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,YAAW,YAAY;IACzD,QAAQ,CAAC,SAAS,2BAA4B;IAE9C,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,YAAY,EAAE;CAsFlD"}

package/dist/edge-resolvers/co-location.js

@@ -0,0 +1,129 @@
+"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.CoLocationEdgeResolver = void 0;
+const path = __importStar(require("path"));
+/**
+ * Resolves co-location edges — proximity-based connections between functions
+ * in the same file or same directory.
+ *
+ * Same-file: all-pairs with weight decaying by positional distance (1/offset).
+ * Directory (cross-file): half the same-file weight, also decaying by offset.
+ *
+ * Owns a shared dedup Set to prevent duplicate edges across both phases.
+ */
+class CoLocationEdgeResolver {
+    constructor() {
+        this.edgeTypes = ["co_location"];
+    }
+    resolve(ctx) {
+        const edges = [];
+        const colocAdded = new Set();
+        // Phase 1: Same-file co-location
+        for (const fn of ctx.functions) {
+            if (ctx.affectedHashes && !ctx.affectedHashes.has(fn.contentHash))
+                continue;
+            const sortedSiblings = ctx.fileToSortedFns.get(fn.filePath);
+            if (!sortedSiblings || sortedSiblings.length <= 1)
+                continue;
+            const idx = sortedSiblings.indexOf(fn);
+            if (idx < 0)
+                continue;
+            for (let offset = 1; offset < sortedSiblings.length - idx; offset++) {
+                const neighbor = sortedSiblings[idx + offset];
+                if (!neighbor)
+                    break;
+                const a = fn.contentHash < neighbor.contentHash
+                    ? fn.contentHash
+                    : neighbor.contentHash;
+                const b = fn.contentHash < neighbor.contentHash
+                    ? neighbor.contentHash
+                    : fn.contentHash;
+                const key = `${a}|${b}`;
+                if (!colocAdded.has(key)) {
+                    colocAdded.add(key);
+                    edges.push({
+                        sourceHash: a,
+                        targetHash: b,
+                        edgeType: "co_location",
+                        weight: ctx.config.edgeWeights.co_location / offset,
+                    });
+                }
+            }
+        }
+        // Phase 2: Directory co-location (cross-file, same directory)
+        const dirToFns = new Map();
+        for (const fn of ctx.functions) {
+            const dir = path.dirname(fn.filePath);
+            const list = dirToFns.get(dir) || [];
+            list.push(fn);
+            dirToFns.set(dir, list);
+        }
+        const dirWeight = ctx.config.edgeWeights.co_location * 0.5;
+        for (const fns of dirToFns.values()) {
+            const files = new Set(fns.map((f) => f.filePath));
+            if (files.size < 2)
+                continue;
+            fns.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine);
+            for (let i = 0; i < fns.length; i++) {
+                if (ctx.affectedHashes && !ctx.affectedHashes.has(fns[i].contentHash))
+                    continue;
+                for (let j = i + 1; j < fns.length; j++) {
+                    if (fns[i].filePath === fns[j].filePath)
+                        continue;
+                    const a = fns[i].contentHash < fns[j].contentHash
+                        ? fns[i].contentHash
+                        : fns[j].contentHash;
+                    const b = fns[i].contentHash < fns[j].contentHash
+                        ? fns[j].contentHash
+                        : fns[i].contentHash;
+                    const key = `${a}|${b}`;
+                    if (!colocAdded.has(key)) {
+                        colocAdded.add(key);
+                        const offset = j - i;
+                        edges.push({
+                            sourceHash: a,
+                            targetHash: b,
+                            edgeType: "co_location",
+                            weight: dirWeight / offset,
+                        });
+                    }
+                }
+            }
+        }
+        return edges;
+    }
+}
+exports.CoLocationEdgeResolver = CoLocationEdgeResolver;

package/dist/edge-resolvers/import.d.ts

@@ -0,0 +1,16 @@
+import type { EdgeResolver, EdgeResolverContext } from "./types";
+import type { FunctionEdge } from "../graph";
+/**
+ * Resolves import edges from import statements.
+ * Three resolution paths:
+ * 1. Direct: imported name found in the resolved target file
+ * 2. Barrel fallback: imported name found via package-scoped search (re-exports)
+ * 3. Namespace fallback: intersect fn.calls with target file's functions
+ *
+ * Owns importAdded Set for deduplication (import edges are undirected).
+ */
+export declare class ImportEdgeResolver implements EdgeResolver {
+    readonly edgeTypes: readonly ["import"];
+    resolve(ctx: EdgeResolverContext): FunctionEdge[];
+}
+//# sourceMappingURL=import.d.ts.map

package/dist/edge-resolvers/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/edge-resolvers/import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,QAAQ,CAAC,SAAS,sBAAuB;IAEzC,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,YAAY,EAAE;CAqHlD"}

package/dist/edge-resolvers/import.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEdgeResolver = void 0;
+const module_resolvers_1 = require("../module-resolvers");
+/**
+ * Resolves import edges from import statements.
+ * Three resolution paths:
+ * 1. Direct: imported name found in the resolved target file
+ * 2. Barrel fallback: imported name found via package-scoped search (re-exports)
+ * 3. Namespace fallback: intersect fn.calls with target file's functions
+ *
+ * Owns importAdded Set for deduplication (import edges are undirected).
+ */
+class ImportEdgeResolver {
+    constructor() {
+        this.edgeTypes = ["import"];
+    }
+    resolve(ctx) {
+        const edges = [];
+        const importAdded = new Set();
+        for (const fn of ctx.functions) {
+            if (ctx.affectedHashes && !ctx.affectedHashes.has(fn.contentHash))
+                continue;
+            if (!fn.imports)
+                continue;
+            for (const imp of fn.imports) {
+                const langResolver = (0, module_resolvers_1.getModuleResolverForFile)(fn.filePath);
+                const targetFile = langResolver?.resolveModuleToFile(imp.module, fn.filePath, ctx.fileToHashes, ctx.resolver);
+                // Determine package scope for fallback through barrel file re-exports
+                let pkgScope;
+                if (ctx.resolver) {
+                    for (const [pkgName] of ctx.resolver.workspacePackages) {
+                        if (imp.module === pkgName ||
+                            imp.module.startsWith(pkgName + "/")) {
+                            pkgScope = ctx.pkgNameToHashes.get(pkgName);
+                            break;
+                        }
+                    }
+                }
+                if (!targetFile && !pkgScope)
+                    continue;
+                // Create edges to the specific functions named in the import
+                let matched = false;
+                for (const importedName of imp.names) {
+                    // Direct lookup: function defined in the resolved target file
+                    const directHash = targetFile
+                        ? ctx.fileNameToHash.get(`${targetFile}::${importedName}`)
+                        : undefined;
+                    if (directHash && directHash !== fn.contentHash) {
+                        matched = true;
+                        const a = fn.contentHash < directHash ? fn.contentHash : directHash;
+                        const b = fn.contentHash < directHash ? directHash : fn.contentHash;
+                        const importKey = `${a}|${b}`;
+                        if (!importAdded.has(importKey)) {
+                            importAdded.add(importKey);
+                            edges.push({
+                                sourceHash: a,
+                                targetHash: b,
+                                edgeType: "import",
+                                weight: ctx.config.edgeWeights.import,
+                            });
+                        }
+                    }
+                    else if (pkgScope) {
+                        // Fallback: imported name is a re-export through a barrel file
+                        const targetHashes = pkgScope.get(importedName);
+                        if (targetHashes) {
+                            for (const targetHash of targetHashes) {
+                                if (targetHash === fn.contentHash)
+                                    continue;
+                                matched = true;
+                                const a = fn.contentHash < targetHash ? fn.contentHash : targetHash;
+                                const b = fn.contentHash < targetHash ? targetHash : fn.contentHash;
+                                const importKey = `${a}|${b}`;
+                                if (!importAdded.has(importKey)) {
+                                    importAdded.add(importKey);
+                                    edges.push({
+                                        sourceHash: a,
+                                        targetHash: b,
+                                        edgeType: "import",
+                                        weight: ctx.config.edgeWeights.import,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                // Fallback for namespace imports: intersect fn.calls with target file's functions
+                if (!matched && fn.calls && targetFile) {
+                    const targetFnsInFile = ctx.fileToHashes.get(targetFile);
+                    if (targetFnsInFile) {
+                        for (const calledName of fn.calls) {
+                            const targetHash = ctx.fileNameToHash.get(`${targetFile}::${calledName}`);
+                            if (targetHash &&
+                                targetHash !== fn.contentHash &&
+                                targetFnsInFile.has(targetHash)) {
+                                const a = fn.contentHash < targetHash ? fn.contentHash : targetHash;
+                                const b = fn.contentHash < targetHash ? targetHash : fn.contentHash;
+                                const importKey = `${a}|${b}`;
+                                if (!importAdded.has(importKey)) {
+                                    importAdded.add(importKey);
+                                    edges.push({
+                                        sourceHash: a,
+                                        targetHash: b,
+                                        edgeType: "import",
+                                        weight: ctx.config.edgeWeights.import,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return edges;
+    }
+}
+exports.ImportEdgeResolver = ImportEdgeResolver;

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

@@ -0,0 +1,9 @@
+export type { EdgeResolver, EdgeResolverContext } from "./types";
+export { CallEdgeResolver } from "./call";
+export { JsxRefEdgeResolver } from "./jsx-ref";
+export { CoLocationEdgeResolver } from "./co-location";
+export { ImportEdgeResolver } from "./import";
+import type { EdgeResolver } from "./types";
+export declare function registerEdgeResolver(resolver: EdgeResolver): void;
+export declare function getEdgeResolvers(): readonly EdgeResolver[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/edge-resolvers/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAQ5C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAEjE;AAED,wBAAgB,gBAAgB,IAAI,SAAS,YAAY,EAAE,CAE1D"}

package/dist/edge-resolvers/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEdgeResolver = exports.CoLocationEdgeResolver = exports.JsxRefEdgeResolver = exports.CallEdgeResolver = void 0;
+exports.registerEdgeResolver = registerEdgeResolver;
+exports.getEdgeResolvers = getEdgeResolvers;
+var call_1 = require("./call");
+Object.defineProperty(exports, "CallEdgeResolver", { enumerable: true, get: function () { return call_1.CallEdgeResolver; } });
+var jsx_ref_1 = require("./jsx-ref");
+Object.defineProperty(exports, "JsxRefEdgeResolver", { enumerable: true, get: function () { return jsx_ref_1.JsxRefEdgeResolver; } });
+var co_location_1 = require("./co-location");
+Object.defineProperty(exports, "CoLocationEdgeResolver", { enumerable: true, get: function () { return co_location_1.CoLocationEdgeResolver; } });
+var import_1 = require("./import");
+Object.defineProperty(exports, "ImportEdgeResolver", { enumerable: true, get: function () { return import_1.ImportEdgeResolver; } });
+const call_2 = require("./call");
+const jsx_ref_2 = require("./jsx-ref");
+const co_location_2 = require("./co-location");
+const import_2 = require("./import");
+const registry = [];
+function registerEdgeResolver(resolver) {
+    registry.push(resolver);
+}
+function getEdgeResolvers() {
+    return registry;
+}
+// Register built-in resolvers
+registerEdgeResolver(new call_2.CallEdgeResolver());
+registerEdgeResolver(new jsx_ref_2.JsxRefEdgeResolver());
+registerEdgeResolver(new co_location_2.CoLocationEdgeResolver());
+registerEdgeResolver(new import_2.ImportEdgeResolver());

package/dist/edge-resolvers/jsx-ref.d.ts

@@ -0,0 +1,13 @@
+import type { EdgeResolver, EdgeResolverContext } from "./types";
+import type { FunctionEdge } from "../graph";
+/**
+ * Resolves JSX component reference edges.
+ * When a function renders <Component />, creates a weak edge to that component.
+ * Separated from call edges because UI composition is a weaker domain signal
+ * than direct function calls.
+ */
+export declare class JsxRefEdgeResolver implements EdgeResolver {
+    readonly edgeTypes: readonly ["jsx_ref"];
+    resolve(ctx: EdgeResolverContext): FunctionEdge[];
+}
+//# sourceMappingURL=jsx-ref.d.ts.map

package/dist/edge-resolvers/jsx-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-ref.d.ts","sourceRoot":"","sources":["../../src/edge-resolvers/jsx-ref.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,QAAQ,CAAC,SAAS,uBAAwB;IAE1C,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,YAAY,EAAE;CAqBlD"}

package/dist/edge-resolvers/jsx-ref.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsxRefEdgeResolver = void 0;
+/**
+ * Resolves JSX component reference edges.
+ * When a function renders <Component />, creates a weak edge to that component.
+ * Separated from call edges because UI composition is a weaker domain signal
+ * than direct function calls.
+ */
+class JsxRefEdgeResolver {
+    constructor() {
+        this.edgeTypes = ["jsx_ref"];
+    }
+    resolve(ctx) {
+        const edges = [];
+        for (const fn of ctx.functions) {
+            if (ctx.affectedHashes && !ctx.affectedHashes.has(fn.contentHash))
+                continue;
+            if (!fn.jsxRefs)
+                continue;
+            for (const refName of fn.jsxRefs) {
+                const targetHashes = ctx.nameToHashes.get(refName);
+                if (!targetHashes)
+                    continue;
+                for (const targetHash of targetHashes) {
+                    if (targetHash === fn.contentHash)
+                        continue;
+                    edges.push({
+                        sourceHash: fn.contentHash,
+                        targetHash,
+                        edgeType: "jsx_ref",
+                        weight: ctx.config.edgeWeights.jsx_ref,
+                    });
+                }
+            }
+        }
+        return edges;
+    }
+}
+exports.JsxRefEdgeResolver = JsxRefEdgeResolver;

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

@@ -0,0 +1,40 @@
+import type { FunctionInfo } from "../shared";
+import type { GraphConfig, FunctionEdge, ModuleResolver } from "../graph";
+/**
+ * Shared context built once per resolveEdges() invocation.
+ * Contains pre-built lookup maps that edge resolvers need.
+ * The orchestrator builds this — resolvers consume it.
+ */
+export interface EdgeResolverContext {
+    /** function_name → Set<content_hash> (handles name collisions across files) */
+    nameToHashes: Map<string, Set<string>>;
+    /** file_path → Set<content_hash> */
+    fileToHashes: Map<string, Set<string>>;
+    /** "file_path::function_name" → content_hash (targeted import lookup) */
+    fileNameToHash: Map<string, string>;
+    /** package_name → Map<function_name, Set<content_hash>> (barrel file fallback) */
+    pkgNameToHashes: Map<string, Map<string, Set<string>>>;
+    /** file_path → FunctionInfo[] sorted by startLine */
+    fileToSortedFns: Map<string, FunctionInfo[]>;
+    /** All extracted functions for this scan */
+    functions: FunctionInfo[];
+    /** Graph configuration (edge weights, etc.) */
+    config: GraphConfig;
+    /** Optional: limit resolution to these hashes (incremental mode) */
+    affectedHashes?: Set<string>;
+    /** Optional: workspace module resolver for import resolution */
+    resolver?: ModuleResolver;
+}
+/**
+ * Strategy interface for edge resolution.
+ * Each implementation handles one category of edges (calls, imports, co-location, etc.).
+ *
+ * Resolvers own their own deduplication — the orchestrator concatenates results.
+ */
+export interface EdgeResolver {
+    /** Edge type identifier(s) this resolver produces */
+    readonly edgeTypes: readonly string[];
+    /** Resolve edges from the shared context */
+    resolve(ctx: EdgeResolverContext): FunctionEdge[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/edge-resolvers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1E;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,+EAA+E;IAC/E,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACvC,oCAAoC;IACpC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACvC,yEAAyE;IACzE,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,kFAAkF;IAClF,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACvD,qDAAqD;IACrD,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAC7C,4CAA4C;IAC5C,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,+CAA+C;IAC/C,MAAM,EAAE,WAAW,CAAC;IACpB,oEAAoE;IACpE,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,4CAA4C;IAC5C,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,YAAY,EAAE,CAAC;CACnD"}

package/dist/edge-resolvers/types.js

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