@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/local-llm.test.js

@@ -0,0 +1,253 @@
+/**
+ * Sprint L3.1 Tests: BYO-LLM Adapter Factory — adapter creation, embedding, health check.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAndVerifyAdapter, createLocalLlmAdapter, } from "../intelligence/local-llm.js";
+// ── Adapter Factory ─────────────────────────────────────────
+describe("createLocalLlmAdapter", () => {
+    it("returns null when config is undefined", () => {
+        expect(createLocalLlmAdapter(undefined)).toBeNull();
+    });
+    it("creates Ollama adapter with defaults", () => {
+        const config = {
+            provider: "ollama",
+            embeddingModel: "nomic-embed-text",
+            chatModel: "llama3",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        };
+        const adapter = createLocalLlmAdapter(config);
+        expect(adapter).not.toBeNull();
+        expect(adapter?.provider).toBe("ollama");
+        expect(adapter?.baseUrl).toBe("http://localhost:11434");
+        expect(adapter?.embeddingModel).toBe("nomic-embed-text");
+        expect(adapter?.embeddingDimensions).toBe(384);
+        expect(adapter?.maxConcurrency).toBe(2);
+    });
+    it("creates LM Studio adapter with custom baseUrl", () => {
+        const config = {
+            provider: "lm-studio",
+            baseUrl: "http://localhost:5555",
+            embeddingModel: "all-MiniLM-L6-v2",
+            chatModel: "llama3",
+            maxConcurrency: 4,
+            embeddingDimensions: 384,
+        };
+        const adapter = createLocalLlmAdapter(config);
+        expect(adapter?.provider).toBe("lm-studio");
+        expect(adapter?.baseUrl).toBe("http://localhost:5555");
+    });
+    it("creates OpenAI-compatible adapter", () => {
+        const config = {
+            provider: "openai-compatible",
+            baseUrl: "http://localhost:8080",
+            embeddingModel: "text-embedding-3-small",
+            chatModel: "gpt-4o",
+            apiKey: "sk-test",
+            maxConcurrency: 2,
+            embeddingDimensions: 1536,
+        };
+        const adapter = createLocalLlmAdapter(config);
+        expect(adapter?.provider).toBe("openai-compatible");
+    });
+    it("creates Anthropic-direct adapter", () => {
+        const config = {
+            provider: "anthropic-direct",
+            embeddingModel: "nomic-embed-text",
+            chatModel: "claude-sonnet-4-20250514",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        };
+        const adapter = createLocalLlmAdapter(config);
+        expect(adapter?.provider).toBe("anthropic-direct");
+        expect(adapter?.baseUrl).toBe("https://api.anthropic.com");
+    });
+});
+// ── Embed Method ────────────────────────────────────────────
+describe("adapter.embed", () => {
+    let adapter;
+    beforeEach(() => {
+        adapter = createLocalLlmAdapter({
+            provider: "ollama",
+            embeddingModel: "nomic-embed-text",
+            chatModel: "llama3",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+    });
+    it("returns empty result for empty input", async () => {
+        const result = await adapter.embed([]);
+        expect(result.embeddings).toEqual([]);
+        expect(result.totalTokens).toBe(0);
+    });
+    it("calls /v1/embeddings with correct payload", async () => {
+        const mockResponse = {
+            data: [
+                { embedding: [0.1, 0.2, 0.3], index: 0 },
+                { embedding: [0.4, 0.5, 0.6], index: 1 },
+            ],
+            model: "nomic-embed-text",
+            usage: { prompt_tokens: 10, total_tokens: 10 },
+        };
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+        const result = await adapter.embed(["hello", "world"]);
+        expect(fetchSpy).toHaveBeenCalledOnce();
+        const call = fetchSpy.mock.calls[0];
+        const [url, init] = call ?? [];
+        expect(url).toBe("http://localhost:11434/v1/embeddings");
+        expect(init?.method).toBe("POST");
+        const body = JSON.parse(init?.body);
+        expect(body.model).toBe("nomic-embed-text");
+        expect(body.input).toEqual(["hello", "world"]);
+        expect(result.embeddings).toHaveLength(2);
+        expect(result.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+        expect(result.embeddings[1]).toEqual([0.4, 0.5, 0.6]);
+        expect(result.totalTokens).toBe(10);
+        fetchSpy.mockRestore();
+    });
+    it("sorts response by index to preserve order", async () => {
+        const mockResponse = {
+            data: [
+                { embedding: [0.4, 0.5], index: 1 },
+                { embedding: [0.1, 0.2], index: 0 },
+            ],
+            model: "nomic-embed-text",
+            usage: { prompt_tokens: 5, total_tokens: 5 },
+        };
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+        const result = await adapter.embed(["first", "second"]);
+        expect(result.embeddings[0]).toEqual([0.1, 0.2]);
+        expect(result.embeddings[1]).toEqual([0.4, 0.5]);
+        fetchSpy.mockRestore();
+    });
+    it("throws on non-200 response", async () => {
+        const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response("model not found", {
+            status: 404,
+            statusText: "Not Found",
+        }));
+        await expect(adapter.embed(["test"])).rejects.toThrow("404 Not Found");
+        fetchSpy.mockRestore();
+    });
+    it("includes Authorization header when apiKey is set", async () => {
+        const adapterWithKey = createLocalLlmAdapter({
+            provider: "openai-compatible",
+            baseUrl: "http://localhost:8080",
+            embeddingModel: "test-model",
+            chatModel: "test",
+            apiKey: "sk-secret",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+        const mockResponse = {
+            data: [{ embedding: [0.1], index: 0 }],
+            model: "test-model",
+            usage: { prompt_tokens: 1, total_tokens: 1 },
+        };
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+        await adapterWithKey.embed(["test"]);
+        const headers = fetchSpy.mock.calls[0]?.[1]?.headers;
+        expect(headers.Authorization).toBe("Bearer sk-secret");
+        fetchSpy.mockRestore();
+    });
+});
+// ── Health Check ────────────────────────────────────────────
+describe("adapter.isAvailable", () => {
+    it("returns true when endpoint responds 200", async () => {
+        const adapter = createLocalLlmAdapter({
+            provider: "ollama",
+            embeddingModel: "nomic-embed-text",
+            chatModel: "llama3",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(new Response(JSON.stringify({ models: [] }), { status: 200 }));
+        expect(await adapter.isAvailable()).toBe(true);
+        // Ollama uses /api/tags
+        expect(fetchSpy.mock.calls[0]?.[0]).toBe("http://localhost:11434/api/tags");
+        fetchSpy.mockRestore();
+    });
+    it("returns false when endpoint is unreachable", async () => {
+        const adapter = createLocalLlmAdapter({
+            provider: "ollama",
+            embeddingModel: "nomic-embed-text",
+            chatModel: "llama3",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockRejectedValue(new Error("ECONNREFUSED"));
+        expect(await adapter.isAvailable()).toBe(false);
+        fetchSpy.mockRestore();
+    });
+    it("LM Studio uses /v1/models endpoint", async () => {
+        const adapter = createLocalLlmAdapter({
+            provider: "lm-studio",
+            embeddingModel: "test",
+            chatModel: "test",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(new Response(JSON.stringify({ data: [] }), { status: 200 }));
+        await adapter.isAvailable();
+        expect(fetchSpy.mock.calls[0]?.[0]).toBe("http://localhost:1234/v1/models");
+        fetchSpy.mockRestore();
+    });
+});
+// ── createAndVerifyAdapter ──────────────────────────────────
+describe("createAndVerifyAdapter", () => {
+    it("returns null for undefined config", async () => {
+        expect(await createAndVerifyAdapter(undefined)).toBeNull();
+    });
+    it("logs available status to stderr", async () => {
+        const stderrSpy = vi.spyOn(process.stderr, "write").mockReturnValue(true);
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(new Response(JSON.stringify({ models: [] }), { status: 200 }));
+        const adapter = await createAndVerifyAdapter({
+            provider: "ollama",
+            embeddingModel: "nomic-embed-text",
+            chatModel: "llama3",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+        expect(adapter).not.toBeNull();
+        const output = stderrSpy.mock.calls.map((c) => c[0]).join("");
+        expect(output).toContain("BYO-LLM");
+        expect(output).toContain("ollama");
+        // API key should NEVER appear in stderr
+        expect(output).not.toContain("sk-");
+        stderrSpy.mockRestore();
+        fetchSpy.mockRestore();
+    });
+    it("logs unavailable status without leaking apiKey", async () => {
+        const stderrSpy = vi.spyOn(process.stderr, "write").mockReturnValue(true);
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockRejectedValue(new Error("ECONNREFUSED"));
+        await createAndVerifyAdapter({
+            provider: "openai-compatible",
+            baseUrl: "http://localhost:9999",
+            embeddingModel: "test",
+            chatModel: "test",
+            apiKey: "sk-supersecret-key",
+            maxConcurrency: 2,
+            embeddingDimensions: 384,
+        });
+        const output = stderrSpy.mock.calls.map((c) => c[0]).join("");
+        expect(output).toContain("not reachable");
+        expect(output).not.toContain("sk-supersecret-key");
+        stderrSpy.mockRestore();
+        fetchSpy.mockRestore();
+    });
+});

package/dist/__tests__/local-mode-offline.test.js

@@ -0,0 +1,187 @@
+/**
+ * Sprint L5.1 — Offline Integration Test Suite
+ *
+ * Proves that Local Mode makes exactly zero outbound network calls
+ * under all code paths. Boots a mock QueryRouter in Local Mode,
+ * exercises every local MCP tool, and asserts zero non-localhost fetch calls.
+ *
+ * CONTRACT: TL-1, TL-12, TL-15
+ */
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi, } from "vitest";
+import { getBlockedCount, resetBlockedCount, seal, unseal, } from "../proxy/network-firewall.js";
+const networkCallLog = [];
+let originalFetch;
+function extractHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return null;
+    }
+}
+const LOCALHOST_NAMES = new Set(["localhost", "127.0.0.1", "::1", "0.0.0.0"]);
+function isLocalhostUrl(hostname) {
+    if (!hostname)
+        return false;
+    return LOCALHOST_NAMES.has(hostname) || hostname.endsWith(".local");
+}
+function getNonLocalhostCalls() {
+    return networkCallLog.filter((c) => !isLocalhostUrl(c.hostname));
+}
+// ── Mock Graph + Router ────────────────────────────────────────────
+function createMockLocalGraph() {
+    const mockEntity = {
+        key: "fn::test",
+        kind: "function",
+        name: "testFn",
+        file_path: "src/test.ts",
+        start_line: 1,
+        end_line: 10,
+        signature: "(): void",
+        body: "function testFn() {}",
+        fan_in: 2,
+        fan_out: 1,
+        risk_level: "normal",
+    };
+    const mockDb = {
+        run: vi.fn((_query) => ({
+            rows: [],
+        })),
+    };
+    return {
+        db: mockDb,
+        getEntity: vi.fn().mockReturnValue(mockEntity),
+        getCallersOf: vi.fn().mockReturnValue([]),
+        getCalleesOf: vi.fn().mockReturnValue([]),
+        getEntitiesByFile: vi.fn().mockReturnValue([mockEntity]),
+        searchEntities: vi.fn().mockReturnValue([mockEntity]),
+        getImports: vi.fn().mockReturnValue([]),
+        hasRules: vi.fn().mockReturnValue(true),
+        getRules: vi.fn().mockReturnValue([]),
+        getPatterns: vi
+            .fn()
+            .mockReturnValue([
+            { name: "test-pattern", type: "naming", adherence: 0.9 },
+        ]),
+        hasJustifications: vi.fn().mockReturnValue(true),
+        getBusinessContext: vi.fn().mockReturnValue(null),
+        getConventions: vi.fn().mockReturnValue([]),
+        getCrossBoundaryLinks: vi.fn().mockReturnValue([]),
+        getCriticalNodes: vi.fn().mockReturnValue([]),
+        getDriftEntitiesForFile: vi.fn().mockReturnValue([]),
+        upsertDriftEntity: vi.fn(),
+        removeDriftEntity: vi.fn(),
+        clearDriftOverlay: vi.fn(),
+        getDriftSummary: vi
+            .fn()
+            .mockReturnValue({ added: 0, modified: 0, deleted: 0, total: 0 }),
+        healthCheck: vi.fn().mockReturnValue({ status: "ok", latencyMs: 1 }),
+        isLoaded: vi.fn().mockReturnValue(true),
+        loadSnapshot: vi.fn(),
+        loadRules: vi.fn(),
+        loadPatterns: vi.fn(),
+        loadJustifications: vi.fn(),
+        applyDelta: vi.fn().mockReturnValue({
+            applied: 0,
+            deleted: 0,
+            edges: 0,
+            justifications: 0,
+            overlayExpired: 0,
+        }),
+        getLocalProjectStats: vi.fn().mockReturnValue({
+            fileCount: 100,
+            entityCount: 500,
+            edgeCount: 1200,
+            communityCount: 10,
+            ruleCount: 5,
+        }),
+        getDeepDiveProjectState: vi.fn().mockReturnValue("none"),
+        persistCorrections: vi.fn(),
+        getRuleHealthSummary: vi.fn().mockReturnValue(null),
+        getRuleExceptions: vi.fn().mockReturnValue([]),
+    };
+}
+// ── Test Suite ─────────────────────────────────────────────────────
+describe("Local Mode — Zero Network Leakage (L5.1)", () => {
+    beforeAll(() => {
+        originalFetch = globalThis.fetch;
+        globalThis.fetch = ((input, init) => {
+            const url = typeof input === "string"
+                ? input
+                : input instanceof URL
+                    ? input.toString()
+                    : input.url;
+            const hostname = extractHostname(url);
+            networkCallLog.push({
+                url,
+                method: init?.method ?? "GET",
+                hostname,
+            });
+            if (hostname && !isLocalhostUrl(hostname)) {
+                return Promise.reject(new Error(`[TEST GUARD] Outbound network call detected to ${hostname}: ${url}`));
+            }
+            return originalFetch(input, init);
+        });
+    });
+    afterAll(() => {
+        globalThis.fetch = originalFetch;
+    });
+    afterEach(() => {
+        unseal();
+        resetBlockedCount();
+        networkCallLog.length = 0;
+    });
+    it("NetworkFirewall blocks outbound calls with zero leakage", async () => {
+        seal();
+        expect(getBlockedCount()).toBe(0);
+        const externalUrls = [
+            "https://app.unerr.dev/api/health",
+            "https://api.anthropic.com/v1/messages",
+            "https://cloud.example.com/sync",
+        ];
+        for (const url of externalUrls) {
+            const result = await globalThis.fetch(url).catch((e) => e);
+            expect(result).toBeInstanceOf(Error);
+            expect(result.message).toContain("[NetworkFirewall]");
+        }
+        expect(getBlockedCount()).toBe(3);
+    });
+    it("all 14+ local MCP tools respond without network calls via QueryRouter", async () => {
+        seal();
+        networkCallLog.length = 0;
+        const { QueryRouter } = await import("../intelligence/query-router.js");
+        const graph = createMockLocalGraph();
+        const router = new QueryRouter(graph);
+        router.setMode("local", "Local Mode");
+        const localTools = [
+            { name: "get_function", args: { key: "fn::test" } },
+            { name: "get_class", args: { key: "cls::test" } },
+            { name: "get_file", args: { key: "src/test.ts" } },
+            { name: "get_callers", args: { key: "fn::test" } },
+            { name: "get_callees", args: { key: "fn::test" } },
+            { name: "get_imports", args: { file_path: "src/test.ts" } },
+            { name: "search_code", args: { query: "test" } },
+            { name: "get_rules", args: {} },
+            { name: "get_business_context", args: { key: "fn::test" } },
+            { name: "get_conventions", args: {} },
+            { name: "get_cross_boundary_links", args: {} },
+            { name: "get_critical_nodes", args: {} },
+        ];
+        for (const tool of localTools) {
+            const result = await router.execute(tool.name, tool.args);
+            expect(result._meta.source).toBe("local");
+        }
+        expect(getNonLocalhostCalls().length).toBe(0);
+        expect(getBlockedCount()).toBe(0);
+    });
+    it("aggregate: zero non-localhost calls across full Local Mode exercise", () => {
+        seal();
+        networkCallLog.length = 0;
+        const stderrSpy = vi.spyOn(process.stderr, "write").mockReturnValue(true);
+        void globalThis.fetch("http://localhost:11434/api/tags").catch(() => { });
+        void globalThis.fetch("http://127.0.0.1:8080/health").catch(() => { });
+        expect(getNonLocalhostCalls().length).toBe(0);
+        expect(getBlockedCount()).toBe(0);
+        stderrSpy.mockRestore();
+    });
+});