@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/indexer-cfg.test.js

@@ -0,0 +1,185 @@
+/**
+ * Sprint J.9: CFG context accuracy tests.
+ *
+ * Tests that call sites are correctly annotated with their
+ * control-flow context: try/catch, loops, conditionals.
+ */
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { cfgToEdgeFields, extractCFGContext, } from "../intelligence/indexer/cfg-context.js";
+import { detectMutations, mutationsToEdges, } from "../intelligence/indexer/mutation-tracker.js";
+import { registerPlugin } from "../intelligence/indexer/plugin-interface.js";
+import { typescriptPlugin } from "../intelligence/indexer/plugins/typescript.js";
+import { clearParserCache, parseSource, } from "../intelligence/tree-sitter-loader.js";
+beforeAll(() => {
+    registerPlugin(typescriptPlugin);
+});
+afterAll(() => {
+    clearParserCache();
+});
+async function findCallNodes(source) {
+    const tree = await parseSource(source, "tree-sitter-typescript.wasm");
+    const calls = [];
+    function visit(node) {
+        if (node.type === "call_expression") {
+            calls.push(node);
+        }
+        for (const child of node.namedChildren) {
+            visit(child);
+        }
+    }
+    visit(tree.rootNode);
+    return calls;
+}
+async function findFunctionBody(source, fnName) {
+    const tree = await parseSource(source, "tree-sitter-typescript.wasm");
+    function visit(node) {
+        if (node.type === "function_declaration" ||
+            node.type === "method_definition") {
+            const name = node.childForFieldName("name");
+            if (name?.text === fnName) {
+                return node.childForFieldName("body") ?? null;
+            }
+        }
+        for (const child of node.namedChildren) {
+            const found = visit(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    return visit(tree.rootNode);
+}
+describe("CFG Context (J.4)", () => {
+    it("detects try/catch guarded call", async () => {
+        const source = `
+      function safe() {
+        try {
+          dangerousCall();
+        } catch (e) {
+          handleError(e);
+        }
+      }
+    `;
+        const calls = await findCallNodes(source);
+        const dangerousCall = calls.find((c) => c.text.includes("dangerousCall"));
+        expect(dangerousCall).toBeDefined();
+        const cfg = extractCFGContext(dangerousCall);
+        expect(cfg.isTryGuarded).toBe(true);
+    });
+    it("detects loop context", async () => {
+        const source = `
+      function loopy() {
+        for (const item of items) {
+          process(item);
+        }
+      }
+    `;
+        const calls = await findCallNodes(source);
+        const processCall = calls.find((c) => c.text.includes("process"));
+        expect(processCall).toBeDefined();
+        const cfg = extractCFGContext(processCall);
+        expect(cfg.isLoop).toBe(true);
+    });
+    it("detects conditional context", async () => {
+        const source = `
+      function conditional(x: boolean) {
+        if (x) {
+          doSomething();
+        }
+      }
+    `;
+        const calls = await findCallNodes(source);
+        const doCall = calls.find((c) => c.text.includes("doSomething"));
+        expect(doCall).toBeDefined();
+        const cfg = extractCFGContext(doCall);
+        expect(cfg.isConditional).toBe(true);
+    });
+    it("detects error handler context", async () => {
+        const source = `
+      function handler() {
+        try {
+          riskyOp();
+        } catch (e) {
+          logError(e);
+        }
+      }
+    `;
+        const calls = await findCallNodes(source);
+        const logCall = calls.find((c) => c.text.includes("logError"));
+        expect(logCall).toBeDefined();
+        const cfg = extractCFGContext(logCall);
+        expect(cfg.isErrorHandler).toBe(true);
+    });
+    it("detects nested control flow depth", async () => {
+        const source = `
+      function deep() {
+        for (let i = 0; i < 10; i++) {
+          if (i > 5) {
+            process(i);
+          }
+        }
+      }
+    `;
+        const calls = await findCallNodes(source);
+        const processCall = calls.find((c) => c.text.includes("process"));
+        expect(processCall).toBeDefined();
+        const cfg = extractCFGContext(processCall);
+        expect(cfg.isLoop).toBe(true);
+        expect(cfg.isConditional).toBe(true);
+        expect(cfg.nestingDepth).toBeGreaterThanOrEqual(2);
+    });
+    it("converts CFG to edge fields", () => {
+        const cfg = {
+            isTryGuarded: true,
+            isLoop: true,
+            isConditional: false,
+            isErrorHandler: false,
+            isAsync: true,
+            nestingDepth: 2,
+        };
+        const fields = cfgToEdgeFields(cfg);
+        expect(fields.is_try_guarded).toBe(true);
+        expect(fields.is_loop).toBe(true);
+        expect(fields.is_async).toBe(true);
+        expect(fields.nesting_depth).toBe(2);
+        expect(fields.is_conditional).toBeUndefined();
+    });
+});
+describe("State Mutation Detection (J.5)", () => {
+    it("detects this.property mutations", async () => {
+        const body = await findFunctionBody(`class Counter {
+        count = 0;
+        increment() {
+          this.count = this.count + 1;
+        }
+      }`, "increment");
+        expect(body).not.toBeNull();
+        const mutations = detectMutations(body);
+        expect(mutations.length).toBeGreaterThanOrEqual(1);
+        expect(mutations[0]?.isThisMutation).toBe(true);
+        expect(mutations[0]?.propertyName).toBe("count");
+    });
+    it("detects object property mutations", async () => {
+        const body = await findFunctionBody(`function update(config: any) {
+        config.value = 42;
+      }`, "update");
+        expect(body).not.toBeNull();
+        const mutations = detectMutations(body);
+        expect(mutations.length).toBeGreaterThanOrEqual(1);
+        expect(mutations[0]?.isThisMutation).toBe(false);
+    });
+    it("converts mutations to writes edges", () => {
+        const mutations = [
+            {
+                target: "this.count",
+                isThisMutation: true,
+                line: 5,
+                propertyName: "count",
+            },
+        ];
+        const edges = mutationsToEdges(mutations, "method-key", "counter.ts");
+        expect(edges).toHaveLength(1);
+        expect(edges[0]?.type).toBe("writes");
+        expect(edges[0]?.from_key).toBe("method-key");
+    });
+});

package/dist/__tests__/indexer-cross-file.test.js

@@ -0,0 +1,172 @@
+/**
+ * Sprint J.8: Cross-file resolution tests.
+ *
+ * Tests multi-file scenarios: imports, cross-file calls, barrel files,
+ * fan-in/fan-out computation, hub node detection.
+ */
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { applyCentrality, computeCentrality, riskLevel, } from "../intelligence/indexer/centrality.js";
+import { resolveCrossFileEdges } from "../intelligence/indexer/cross-file-resolver.js";
+import { buildExportMap } from "../intelligence/indexer/export-map.js";
+import { registerPlugin } from "../intelligence/indexer/plugin-interface.js";
+import { typescriptPlugin } from "../intelligence/indexer/plugins/typescript.js";
+import { clearParserCache, parseSource, } from "../intelligence/tree-sitter-loader.js";
+beforeAll(() => {
+    registerPlugin(typescriptPlugin);
+});
+afterAll(() => {
+    clearParserCache();
+});
+const FILE_A = `
+import { fetchUser } from "./user-service";
+import { Logger } from "./logger";
+
+export function processOrder(orderId: string) {
+  const user = fetchUser(orderId);
+  Logger.info("Processing order", orderId);
+  return { orderId, user };
+}
+`;
+const FILE_B = `
+export async function fetchUser(id: string): Promise<User> {
+  return { id, name: "Test" };
+}
+
+export interface User {
+  id: string;
+  name: string;
+}
+`;
+const FILE_BARREL = `
+export { fetchUser } from "./user-service";
+export { processOrder } from "./order-handler";
+`;
+async function extractFile(source, filePath) {
+    const tree = await parseSource(source, "tree-sitter-typescript.wasm");
+    const extraction = typescriptPlugin.extract(tree, filePath, source);
+    const imports = typescriptPlugin.resolveImports(tree, filePath);
+    tree.delete();
+    return { ...extraction, imports };
+}
+describe("Export Map (J.1)", () => {
+    it("builds export map from file results", async () => {
+        const fileB = await extractFile(FILE_B, "src/user-service.ts");
+        const fileResults = new Map();
+        fileResults.set("src/user-service.ts", fileB);
+        const exportMap = buildExportMap(fileResults);
+        const exports = exportMap.getAllExports("src/user-service.ts");
+        expect(exports.length).toBeGreaterThan(0);
+        const fetchExport = exports.find((e) => e.name === "fetchUser");
+        expect(fetchExport).toBeDefined();
+        expect(fetchExport?.kind).toBe("function");
+    });
+});
+describe("Cross-File Resolution (J.2)", () => {
+    it("resolves imports to entity keys", async () => {
+        const fileA = await extractFile(FILE_A, "src/order-handler.ts");
+        const fileB = await extractFile(FILE_B, "src/user-service.ts");
+        const fileResults = new Map();
+        fileResults.set("src/order-handler.ts", fileA);
+        fileResults.set("src/user-service.ts", fileB);
+        const result = resolveCrossFileEdges(fileResults);
+        expect(result.resolvedCount).toBeGreaterThan(0);
+        const resolvedCallEdges = result.resolvedEdges.filter((e) => e.type === "calls" && !e.to_key.startsWith("unresolved:"));
+        expect(resolvedCallEdges.length).toBeGreaterThan(0);
+    });
+    it("local calls resolve without imports", async () => {
+        const source = `
+      function helper() { return 42; }
+      export function main() { return helper(); }
+    `;
+        const file = await extractFile(source, "src/local.ts");
+        const fileResults = new Map();
+        fileResults.set("src/local.ts", file);
+        const result = resolveCrossFileEdges(fileResults);
+        const localCalls = result.resolvedEdges.filter((e) => e.type === "calls" && !e.to_key.startsWith("unresolved:"));
+        expect(localCalls.length).toBeGreaterThan(0);
+    });
+});
+describe("Barrel File Resolution (J.3)", () => {
+    it("resolves re-exports through barrel files", async () => {
+        const fileB = await extractFile(FILE_B, "src/user-service.ts");
+        const fileBarrel = await extractFile(FILE_BARREL, "src/index.ts");
+        const fileResults = new Map();
+        fileResults.set("src/user-service.ts", fileB);
+        fileResults.set("src/index.ts", fileBarrel);
+        const exportMap = buildExportMap(fileResults);
+        const barrelExports = exportMap.getAllExports("src/index.ts");
+        expect(barrelExports.length).toBeGreaterThanOrEqual(0);
+    });
+});
+describe("Centrality (J.6 + J.7)", () => {
+    it("computes fan-in and fan-out", () => {
+        const edges = [
+            {
+                from_key: "a",
+                to_key: "target",
+                type: "calls",
+                file_path: "f.ts",
+                line: 1,
+            },
+            {
+                from_key: "b",
+                to_key: "target",
+                type: "calls",
+                file_path: "f.ts",
+                line: 2,
+            },
+            {
+                from_key: "c",
+                to_key: "target",
+                type: "calls",
+                file_path: "f.ts",
+                line: 3,
+            },
+            {
+                from_key: "target",
+                to_key: "d",
+                type: "calls",
+                file_path: "f.ts",
+                line: 4,
+            },
+        ];
+        const result = computeCentrality(edges);
+        expect(result.fanIn.get("target")).toBe(3);
+        expect(result.fanOut.get("target")).toBe(1);
+    });
+    it("detects hub nodes at threshold", () => {
+        const edges = Array.from({ length: 25 }, (_, i) => ({
+            from_key: `caller-${i}`,
+            to_key: "hub-entity",
+            type: "calls",
+            file_path: "f.ts",
+            line: i + 1,
+        }));
+        const result = computeCentrality(edges);
+        expect(result.hubNodes).toContain("hub-entity");
+    });
+    it("assigns correct risk levels", () => {
+        expect(riskLevel(0)).toBe("normal");
+        expect(riskLevel(5)).toBe("normal");
+        expect(riskLevel(10)).toBe("medium");
+        expect(riskLevel(20)).toBe("high");
+        expect(riskLevel(50)).toBe("critical");
+        expect(riskLevel(100)).toBe("critical");
+    });
+    it("applies centrality to entities", () => {
+        const entities = [
+            { key: "target", kind: "function", name: "fn", file_path: "f.ts" },
+        ];
+        const edges = Array.from({ length: 15 }, (_, i) => ({
+            from_key: `caller-${i}`,
+            to_key: "target",
+            type: "calls",
+            file_path: "f.ts",
+            line: i + 1,
+        }));
+        const updated = applyCentrality(entities, edges);
+        const entity = updated[0];
+        expect(entity.fan_in).toBe(15);
+        expect(entity.risk_level).toBe("medium");
+    });
+});

package/dist/__tests__/indexer-extraction.test.js

@@ -0,0 +1,245 @@
+/**
+ * Sprint I.10: Indexer extraction accuracy tests.
+ *
+ * Tests tree-sitter-based entity/edge extraction against known fixtures.
+ * Verifies: entity counts, kinds, deterministic keys, edges, imports.
+ */
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { bodyHash, entityKey } from "../intelligence/indexer/entity-key.js";
+import { getPluginForFile, registerPlugin, } from "../intelligence/indexer/plugin-interface.js";
+import { typescriptPlugin } from "../intelligence/indexer/plugins/typescript.js";
+import { clearParserCache, parseSource, } from "../intelligence/tree-sitter-loader.js";
+beforeAll(() => {
+    registerPlugin(typescriptPlugin);
+});
+afterAll(() => {
+    clearParserCache();
+});
+const FIXTURE_TS = `
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Config } from "./types";
+
+export const VERSION = "1.0.0";
+
+export interface UserOptions {
+  name: string;
+  age?: number;
+}
+
+export type UserId = string | number;
+
+export enum Status {
+  Active = "active",
+  Inactive = "inactive",
+}
+
+export function greet(name: string): string {
+  return \`Hello, \${name}\`;
+}
+
+export async function fetchUser(id: UserId): Promise<UserOptions> {
+  const data = readFileSync(join("data", String(id)), "utf-8");
+  return JSON.parse(data);
+}
+
+export class UserService {
+  private users: Map<string, UserOptions> = new Map();
+
+  constructor(private config: Config) {}
+
+  async getUser(id: string): Promise<UserOptions | null> {
+    const cached = this.users.get(id);
+    if (cached) return cached;
+    const user = await fetchUser(id);
+    this.users.set(id, user);
+    return user;
+  }
+
+  deleteUser(id: string): boolean {
+    return this.users.delete(id);
+  }
+
+  get count(): number {
+    return this.users.size;
+  }
+}
+
+const processOrder = async (orderId: string) => {
+  const user = await fetchUser(orderId);
+  return greet(user.name);
+};
+`;
+describe("Entity Key Generation (I.6)", () => {
+    it("generates deterministic keys", () => {
+        const key1 = entityKey("src/auth.ts", "function", "login", "");
+        const key2 = entityKey("src/auth.ts", "function", "login", "");
+        expect(key1).toBe(key2);
+        expect(key1.length).toBe(16);
+    });
+    it("generates different keys for different entities", () => {
+        const key1 = entityKey("src/auth.ts", "function", "login", "");
+        const key2 = entityKey("src/auth.ts", "function", "logout", "");
+        expect(key1).not.toBe(key2);
+    });
+    it("includes scope in key for nested entities", () => {
+        const topLevel = entityKey("src/auth.ts", "function", "helper", "");
+        const nested = entityKey("src/auth.ts", "function", "helper", "parent-scope");
+        expect(topLevel).not.toBe(nested);
+    });
+    it("generates body hashes", () => {
+        const h1 = bodyHash("function foo() { return 42; }");
+        const h2 = bodyHash("function foo() { return 42; }");
+        const h3 = bodyHash("function foo() { return 43; }");
+        expect(h1).toBe(h2);
+        expect(h1).not.toBe(h3);
+    });
+});
+describe("Plugin Registry (I.2)", () => {
+    it("resolves TypeScript plugin for .ts files", () => {
+        expect(getPluginForFile("src/auth.ts")).toBe(typescriptPlugin);
+    });
+    it("resolves TypeScript plugin for .tsx files", () => {
+        expect(getPluginForFile("src/App.tsx")).toBe(typescriptPlugin);
+    });
+    it("resolves TypeScript plugin for .js files", () => {
+        expect(getPluginForFile("src/utils.js")).toBe(typescriptPlugin);
+    });
+    it("returns null for unsupported extensions", () => {
+        expect(getPluginForFile("README.md")).toBeNull();
+        expect(getPluginForFile("data.json")).toBeNull();
+    });
+});
+describe("TypeScript Entity Extraction (I.3)", () => {
+    let tree;
+    beforeAll(async () => {
+        tree = await parseSource(FIXTURE_TS, "tree-sitter-typescript.wasm");
+    });
+    afterAll(() => {
+        tree.delete();
+    });
+    it("extracts all entity kinds", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const kinds = new Set(result.entities.map((e) => e.kind));
+        expect(kinds).toContain("function");
+        expect(kinds).toContain("class");
+        expect(kinds).toContain("interface");
+        expect(kinds).toContain("type");
+        expect(kinds).toContain("enum");
+        expect(kinds).toContain("variable");
+    });
+    it("extracts named functions", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const greet = result.entities.find((e) => e.name === "greet");
+        expect(greet).toBeDefined();
+        expect(greet?.kind).toBe("function");
+        expect(greet?.exported).toBe(true);
+        expect(greet?.is_async).toBe(false);
+    });
+    it("extracts async functions", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const fetchUser = result.entities.find((e) => e.name === "fetchUser");
+        expect(fetchUser).toBeDefined();
+        expect(fetchUser?.is_async).toBe(true);
+    });
+    it("extracts classes", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const cls = result.entities.find((e) => e.name === "UserService");
+        expect(cls).toBeDefined();
+        expect(cls?.kind).toBe("class");
+    });
+    it("extracts methods within classes", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const methods = result.entities.filter((e) => e.kind === "method" || e.kind === "constructor" || e.kind === "getter");
+        expect(methods.length).toBeGreaterThanOrEqual(2);
+        const getUser = methods.find((e) => e.name === "getUser");
+        expect(getUser).toBeDefined();
+    });
+    it("extracts arrow functions assigned to variables", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const processOrder = result.entities.find((e) => e.name === "processOrder");
+        expect(processOrder).toBeDefined();
+        expect(processOrder?.kind).toBe("function");
+        expect(processOrder?.is_async).toBe(true);
+    });
+    it("extracts interfaces", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const iface = result.entities.find((e) => e.name === "UserOptions");
+        expect(iface).toBeDefined();
+        expect(iface?.kind).toBe("interface");
+    });
+    it("extracts type aliases", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const typeAlias = result.entities.find((e) => e.name === "UserId");
+        expect(typeAlias).toBeDefined();
+        expect(typeAlias?.kind).toBe("type");
+    });
+    it("extracts enums", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const enumEntity = result.entities.find((e) => e.name === "Status");
+        expect(enumEntity).toBeDefined();
+        expect(enumEntity?.kind).toBe("enum");
+    });
+    it("produces deterministic keys across re-runs", () => {
+        const r1 = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const r2 = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const keys1 = r1.entities.map((e) => e.key).sort();
+        const keys2 = r2.entities.map((e) => e.key).sort();
+        expect(keys1).toEqual(keys2);
+    });
+});
+describe("TypeScript Edge Extraction (I.4)", () => {
+    let tree;
+    beforeAll(async () => {
+        tree = await parseSource(FIXTURE_TS, "tree-sitter-typescript.wasm");
+    });
+    afterAll(() => {
+        tree.delete();
+    });
+    it("creates contains edges from class to methods", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const classEntity = result.entities.find((e) => e.name === "UserService");
+        const containsEdges = result.edges.filter((e) => e.type === "contains" && e.from_key === classEntity?.key);
+        expect(containsEdges.length).toBeGreaterThanOrEqual(2);
+    });
+    it("creates calls edges for function calls", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        const callEdges = result.edges.filter((e) => e.type === "calls");
+        expect(callEdges.length).toBeGreaterThan(0);
+    });
+    it("all edges have valid file_path and line", () => {
+        const result = typescriptPlugin.extract(tree, "fixture.ts", FIXTURE_TS);
+        for (const edge of result.edges) {
+            expect(edge.file_path).toBe("fixture.ts");
+            expect(edge.line).toBeGreaterThan(0);
+        }
+    });
+});
+describe("TypeScript Import Resolution (I.5)", () => {
+    let tree;
+    beforeAll(async () => {
+        tree = await parseSource(FIXTURE_TS, "tree-sitter-typescript.wasm");
+    });
+    afterAll(() => {
+        tree.delete();
+    });
+    it("extracts named imports", () => {
+        const imports = typescriptPlugin.resolveImports(tree, "fixture.ts");
+        const fsImport = imports.find((i) => i.source === "node:fs");
+        expect(fsImport).toBeDefined();
+        expect(fsImport?.symbols).toContain("readFileSync");
+    });
+    it("extracts type imports", () => {
+        const imports = typescriptPlugin.resolveImports(tree, "fixture.ts");
+        const typeImport = imports.find((i) => i.source === "./types");
+        expect(typeImport).toBeDefined();
+    });
+    it("resolves import paths", () => {
+        const imports = typescriptPlugin.resolveImports(tree, "fixture.ts");
+        expect(imports.length).toBeGreaterThanOrEqual(3);
+        for (const imp of imports) {
+            expect(imp.source).toBeTruthy();
+            expect(imp.line).toBeGreaterThan(0);
+        }
+    });
+});