@unerr-ai/unerr 0.1.6 → 0.1.7

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

@@ -1,185 +0,0 @@
-/**
- * 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

@@ -1,172 +0,0 @@
-/**
- * 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

@@ -1,245 +0,0 @@
-/**
- * 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);
-        }
-    });
-});