@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/ast-extractor.test.js

@@ -0,0 +1,203 @@
+/**
+ * P10-TEST-03: AST extractor tests — entity extraction from source files.
+ */
+import { describe, expect, it } from "vitest";
+import { detectLanguage, entityKey, extractEntities, } from "../intelligence/ast-extractor.js";
+// ── Language Detection ──────────────────────────────────────────
+describe("detectLanguage", () => {
+    it("detects TypeScript files", () => {
+        expect(detectLanguage("src/index.ts")).toBe("typescript");
+        expect(detectLanguage("components/Button.tsx")).toBe("typescript");
+    });
+    it("detects JavaScript files", () => {
+        expect(detectLanguage("index.js")).toBe("javascript");
+        expect(detectLanguage("config.mjs")).toBe("javascript");
+        expect(detectLanguage("server.cjs")).toBe("javascript");
+    });
+    it("detects Python files", () => {
+        expect(detectLanguage("main.py")).toBe("python");
+    });
+    it("detects Go files", () => {
+        expect(detectLanguage("main.go")).toBe("go");
+    });
+    it("detects Java files", () => {
+        expect(detectLanguage("App.java")).toBe("java");
+    });
+    it("detects Rust files", () => {
+        expect(detectLanguage("main.rs")).toBe("rust");
+    });
+    it("detects C/C++ files", () => {
+        expect(detectLanguage("main.c")).toBe("c");
+        expect(detectLanguage("main.h")).toBe("c");
+        expect(detectLanguage("main.cpp")).toBe("cpp");
+        expect(detectLanguage("main.hpp")).toBe("cpp");
+    });
+    it("returns null for unsupported languages", () => {
+        expect(detectLanguage("data.json")).toBeNull();
+        expect(detectLanguage("style.css")).toBeNull();
+        expect(detectLanguage("readme.md")).toBeNull();
+        expect(detectLanguage("Makefile")).toBeNull();
+    });
+});
+// ── TypeScript/JavaScript Extraction ────────────────────────────
+describe("extractEntities — TypeScript", () => {
+    it("extracts exported functions", () => {
+        const code = `export function processPayment(amount: number): boolean {
+  if (amount <= 0) return false
+  return true
+}`;
+        const entities = extractEntities(code, "src/billing.ts");
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.name).toBe("processPayment");
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.signature).toBe("(amount: number)");
+        expect(entities[0]?.line_start).toBe(1);
+        expect(entities[0]?.line_end).toBe(4);
+    });
+    it("extracts async functions", () => {
+        const code = `export async function fetchData(url: string) {
+  return await fetch(url)
+}`;
+        const entities = extractEntities(code, "src/api.ts");
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.name).toBe("fetchData");
+        expect(entities[0]?.kind).toBe("function");
+    });
+    it("extracts classes", () => {
+        const code = `export class UserService {
+  private db: Database
+
+  getUser(id: string) {
+    return this.db.find(id)
+  }
+}`;
+        const entities = extractEntities(code, "src/user.ts");
+        expect(entities.length).toBeGreaterThanOrEqual(1);
+        const classEntity = entities.find((e) => e.kind === "class");
+        expect(classEntity).toBeDefined();
+        expect(classEntity?.name).toBe("UserService");
+    });
+    it("extracts interfaces", () => {
+        const code = `export interface ApiResponse {
+  data: unknown
+  error?: string
+}`;
+        const entities = extractEntities(code, "src/types.ts");
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.name).toBe("ApiResponse");
+        expect(entities[0]?.kind).toBe("interface");
+    });
+    it("extracts arrow functions assigned to const", () => {
+        const code = `export const validate = (input: string) => {
+  return input.length > 0
+}`;
+        const entities = extractEntities(code, "src/validate.ts");
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.name).toBe("validate");
+        expect(entities[0]?.kind).toBe("function");
+    });
+    it("generates content hash for each entity", () => {
+        const code = `function hello() {
+  console.log("hello")
+}`;
+        const entities = extractEntities(code, "src/greet.ts");
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.content_hash).toBeDefined();
+        expect(entities[0]?.content_hash.length).toBe(16);
+    });
+    it("different content produces different hashes", () => {
+        const code1 = `function hello() {
+  console.log("hello")
+}`;
+        const code2 = `function hello() {
+  console.log("goodbye")
+}`;
+        const e1 = extractEntities(code1, "a.ts");
+        const e2 = extractEntities(code2, "a.ts");
+        expect(e1[0]?.content_hash).not.toBe(e2[0]?.content_hash);
+    });
+});
+// ── Python Extraction ───────────────────────────────────────────
+describe("extractEntities — Python", () => {
+    it("extracts functions and classes", () => {
+        const code = `def process(data):
+    return data.strip()
+
+class DataProcessor:
+    def run(self):
+        pass
+`;
+        const entities = extractEntities(code, "main.py");
+        expect(entities.length).toBeGreaterThanOrEqual(2);
+        const fn = entities.find((e) => e.name === "process");
+        expect(fn).toBeDefined();
+        expect(fn?.kind).toBe("function");
+        const cls = entities.find((e) => e.name === "DataProcessor");
+        expect(cls).toBeDefined();
+        expect(cls?.kind).toBe("class");
+    });
+});
+// ── Go Extraction ───────────────────────────────────────────────
+describe("extractEntities — Go", () => {
+    it("extracts functions and methods", () => {
+        const code = `func main() {
+	fmt.Println("hello")
+}
+
+func (s *Server) Start(port int) error {
+	return s.listen(port)
+}
+
+type Server struct {
+	port int
+}
+`;
+        const entities = extractEntities(code, "main.go");
+        const fn = entities.find((e) => e.name === "main");
+        expect(fn).toBeDefined();
+        expect(fn?.kind).toBe("function");
+        const method = entities.find((e) => e.name === "Start");
+        expect(method).toBeDefined();
+        expect(method?.kind).toBe("method");
+        const cls = entities.find((e) => e.name === "Server");
+        expect(cls).toBeDefined();
+        expect(cls?.kind).toBe("class");
+    });
+});
+// ── Unsupported Languages ───────────────────────────────────────
+describe("extractEntities — unsupported", () => {
+    it("returns empty array for JSON files", () => {
+        expect(extractEntities('{"key": "value"}', "config.json")).toEqual([]);
+    });
+    it("returns empty array for CSS files", () => {
+        expect(extractEntities(".class { color: red; }", "style.css")).toEqual([]);
+    });
+    it("never throws for any input", () => {
+        expect(() => extractEntities("", "test.ts")).not.toThrow();
+        expect(() => extractEntities("random garbage !@#$%", "test.py")).not.toThrow();
+        expect(() => extractEntities("{{{}", "test.go")).not.toThrow();
+    });
+});
+// ── Entity Key Hashing ──────────────────────────────────────────
+describe("entityKey", () => {
+    it("produces 16-char hex string", () => {
+        const key = entityKey("repo1", "src/index.ts", "function", "main");
+        expect(key).toHaveLength(16);
+        expect(/^[a-f0-9]+$/.test(key)).toBe(true);
+    });
+    it("is deterministic", () => {
+        const a = entityKey("repo1", "src/index.ts", "function", "main");
+        const b = entityKey("repo1", "src/index.ts", "function", "main");
+        expect(a).toBe(b);
+    });
+    it("different inputs produce different keys", () => {
+        const a = entityKey("repo1", "src/a.ts", "function", "foo");
+        const b = entityKey("repo1", "src/b.ts", "function", "foo");
+        expect(a).not.toBe(b);
+    });
+    it("includes signature in hash when provided", () => {
+        const a = entityKey("repo1", "src/a.ts", "function", "foo", "(x: number)");
+        const b = entityKey("repo1", "src/a.ts", "function", "foo", "(x: string)");
+        expect(a).not.toBe(b);
+    });
+});

package/dist/__tests__/auto-bootstrap.test.js

@@ -0,0 +1,280 @@
+/**
+ * Tests for auto-bootstrap and PARSE mode (Task 8.4).
+ */
+import { describe, expect, it } from "vitest";
+import { ParseModeIndex, extractEntitiesFromSource, } from "../proxy/auto-bootstrap.js";
+describe("extractEntitiesFromSource", () => {
+    it("extracts exported functions", () => {
+        const code = `export function handlePayment(amount: number): boolean {
+  return amount > 0
+}`;
+        const entities = extractEntitiesFromSource("src/billing.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.name).toBe("handlePayment");
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.key).toBe("src/billing.ts::handlePayment");
+        expect(entities[0]?.line_start).toBe(1);
+        expect(entities[0]?.signature).toBe("handlePayment(amount: number)");
+    });
+    it("extracts async functions", () => {
+        const code = `export async function fetchUser(id: string) {
+  return db.get(id)
+}`;
+        const entities = extractEntitiesFromSource("src/api.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.name).toBe("fetchUser");
+    });
+    it("extracts arrow functions", () => {
+        const code = `export const validate = (input: string): boolean => {
+  return input.length > 0
+}`;
+        const entities = extractEntitiesFromSource("src/utils.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.name).toBe("validate");
+    });
+    it("extracts classes", () => {
+        const code = `export class PaymentService {
+  process(amount: number) {
+    return amount
+  }
+}`;
+        const entities = extractEntitiesFromSource("src/service.ts", code);
+        expect(entities.length).toBeGreaterThanOrEqual(1);
+        const cls = entities.find((e) => e.kind === "class");
+        expect(cls).toBeDefined();
+        expect(cls?.name).toBe("PaymentService");
+    });
+    it("extracts interfaces", () => {
+        const code = `export interface UserConfig {
+  name: string
+  email: string
+}`;
+        const entities = extractEntitiesFromSource("src/types.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("interface");
+        expect(entities[0]?.name).toBe("UserConfig");
+    });
+    it("extracts type aliases", () => {
+        const code = `export type Status = "active" | "inactive"`;
+        const entities = extractEntitiesFromSource("src/types.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("type");
+        expect(entities[0]?.name).toBe("Status");
+    });
+    it("extracts methods inside classes", () => {
+        const code = `export class Router {
+  async execute(name: string) {
+    return name
+  }
+
+  private validate(input: string) {
+    return true
+  }
+}`;
+        const entities = extractEntitiesFromSource("src/router.ts", code);
+        const methods = entities.filter((e) => e.kind === "method");
+        expect(methods.length).toBeGreaterThanOrEqual(2);
+        expect(methods.find((m) => m.name === "Router.execute")).toBeDefined();
+        expect(methods.find((m) => m.name === "Router.validate")).toBeDefined();
+    });
+    it("handles multiple entity types in one file", () => {
+        const code = `export interface Config {
+  key: string
+}
+
+export type Mode = "a" | "b"
+
+export class Service {
+  run() {
+    return true
+  }
+}
+
+export function helper() {
+  return 1
+}`;
+        const entities = extractEntitiesFromSource("src/mixed.ts", code);
+        const kinds = new Set(entities.map((e) => e.kind));
+        expect(kinds.has("interface")).toBe(true);
+        expect(kinds.has("type")).toBe(true);
+        expect(kinds.has("class")).toBe(true);
+        expect(kinds.has("function")).toBe(true);
+    });
+    it("returns empty for empty file", () => {
+        const entities = extractEntitiesFromSource("src/empty.ts", "");
+        expect(entities).toHaveLength(0);
+    });
+    it("does not extract control flow as methods", () => {
+        const code = `export class Foo {
+  bar() {
+    if (true) {
+      for (const x of []) {
+        while (false) {
+          switch (x) {
+            default: break
+          }
+        }
+      }
+    }
+  }
+}`;
+        const entities = extractEntitiesFromSource("src/foo.ts", code);
+        const methods = entities.filter((e) => e.kind === "method");
+        // Should only have 'bar', not 'if', 'for', 'while', 'switch'
+        expect(methods).toHaveLength(1);
+        expect(methods[0]?.name).toBe("Foo.bar");
+    });
+});
+describe("ParseModeIndex", () => {
+    it("indexes and retrieves entities by key", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+            {
+                key: "src/b.ts::Bar",
+                name: "Bar",
+                kind: "class",
+                file_path: "src/b.ts",
+                line_start: 5,
+                signature: "Bar",
+            },
+        ]);
+        expect(index.getEntity("src/a.ts::foo")).toBeDefined();
+        expect(index.getEntity("src/a.ts::foo")?.name).toBe("foo");
+        expect(index.getEntity("nonexistent")).toBeNull();
+    });
+    it("retrieves entities by file", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+            {
+                key: "src/a.ts::bar",
+                name: "bar",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 10,
+                signature: "bar()",
+            },
+            {
+                key: "src/b.ts::Baz",
+                name: "Baz",
+                kind: "class",
+                file_path: "src/b.ts",
+                line_start: 1,
+                signature: "Baz",
+            },
+        ]);
+        expect(index.getEntitiesByFile("src/a.ts")).toHaveLength(2);
+        expect(index.getEntitiesByFile("src/b.ts")).toHaveLength(1);
+        expect(index.getEntitiesByFile("src/c.ts")).toHaveLength(0);
+    });
+    it("searches by name substring", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::handlePayment",
+                name: "handlePayment",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "handlePayment()",
+            },
+            {
+                key: "src/b.ts::processPayment",
+                name: "processPayment",
+                kind: "function",
+                file_path: "src/b.ts",
+                line_start: 1,
+                signature: "processPayment()",
+            },
+            {
+                key: "src/c.ts::getUserName",
+                name: "getUserName",
+                kind: "function",
+                file_path: "src/c.ts",
+                line_start: 1,
+                signature: "getUserName()",
+            },
+        ]);
+        const results = index.search("payment");
+        expect(results).toHaveLength(2);
+    });
+    it("respects search limit", () => {
+        const index = new ParseModeIndex();
+        const entities = Array.from({ length: 20 }, (_, i) => ({
+            key: `src/a.ts::fn${i}`,
+            name: `fn${i}`,
+            kind: "function",
+            file_path: "src/a.ts",
+            line_start: i + 1,
+            signature: `fn${i}()`,
+        }));
+        index.addEntities(entities);
+        expect(index.search("fn", 5)).toHaveLength(5);
+    });
+    it("reports accurate stats", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+            {
+                key: "src/a.ts::bar",
+                name: "bar",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 5,
+                signature: "bar()",
+            },
+            {
+                key: "src/b.ts::Baz",
+                name: "Baz",
+                kind: "class",
+                file_path: "src/b.ts",
+                line_start: 1,
+                signature: "Baz",
+            },
+        ]);
+        const stats = index.getStats();
+        expect(stats.entityCount).toBe(3);
+        expect(stats.fileCount).toBe(2);
+    });
+    it("clears all entities", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+        ]);
+        expect(index.getStats().entityCount).toBe(1);
+        index.clear();
+        expect(index.getStats().entityCount).toBe(0);
+        expect(index.getEntity("src/a.ts::foo")).toBeNull();
+    });
+});