@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/file-logger.test.js

@@ -1,82 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import os from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { installFileLogger } from "../utils/file-logger.js";
-describe("installFileLogger", () => {
-    let tmpDir;
-    let logPath;
-    let uninstall = null;
-    beforeEach(() => {
-        tmpDir = join(os.tmpdir(), `unerr-file-logger-${Date.now()}-${Math.random()}`);
-        mkdirSync(tmpDir, { recursive: true });
-        logPath = join(tmpDir, "mirror.log");
-    });
-    afterEach(() => {
-        if (uninstall) {
-            uninstall();
-            uninstall = null;
-        }
-        rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it("mirrors stderr.write to the target file", () => {
-        uninstall = installFileLogger({ filePath: logPath });
-        process.stderr.write("hello from stderr\n");
-        expect(existsSync(logPath)).toBe(true);
-        expect(readFileSync(logPath, "utf-8")).toContain("hello from stderr");
-    });
-    it("strips ANSI escape codes from the file copy", () => {
-        uninstall = installFileLogger({ filePath: logPath });
-        const colored = "\x1b[31mred text\x1b[0m\n";
-        process.stderr.write(colored);
-        const fileContent = readFileSync(logPath, "utf-8");
-        expect(fileContent).toBe("red text\n");
-        expect(fileContent).not.toContain("\x1b[");
-    });
-    it("rotates when the file exceeds maxBytes", () => {
-        uninstall = installFileLogger({
-            filePath: logPath,
-            maxBytes: 512,
-            keep: 3,
-        });
-        // Write enough bytes to trigger rotation
-        for (let i = 0; i < 20; i++) {
-            process.stderr.write(`${"x".repeat(100)}\n`);
-        }
-        // After rotation, at least one .log.1 should exist
-        expect(existsSync(`${logPath}.1`)).toBe(true);
-    });
-    it("honors the `keep` parameter — older rotations get dropped", () => {
-        uninstall = installFileLogger({
-            filePath: logPath,
-            maxBytes: 256,
-            keep: 2,
-        });
-        // Trigger many rotations
-        for (let cycle = 0; cycle < 6; cycle++) {
-            for (let i = 0; i < 10; i++) {
-                process.stderr.write(`${"x".repeat(100)}\n`);
-            }
-        }
-        // .log, .log.1, .log.2 may exist; .log.3 must not
-        expect(existsSync(`${logPath}.3`)).toBe(false);
-    });
-    it("uninstaller restores original stderr.write", () => {
-        const original = process.stderr.write;
-        const off = installFileLogger({ filePath: logPath });
-        expect(process.stderr.write).not.toBe(original);
-        off();
-        expect(process.stderr.write).toBe(original);
-        // No further writes should land in the file
-        const before = existsSync(logPath) ? readFileSync(logPath, "utf-8") : "";
-        process.stderr.write("post-uninstall noise\n");
-        const after = existsSync(logPath) ? readFileSync(logPath, "utf-8") : "";
-        expect(after).toBe(before);
-    });
-    it("creates the parent directory if missing", () => {
-        const nested = join(tmpDir, "a", "b", "c", "mirror.log");
-        uninstall = installFileLogger({ filePath: nested });
-        process.stderr.write("nested\n");
-        expect(existsSync(nested)).toBe(true);
-    });
-});

package/dist/__tests__/file-outline.test.js

@@ -1,141 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { buildFileOutline } from "../tools/coding/file-outline.js";
-function makeTmpDir(label) {
-    const dir = join(tmpdir(), `fo-${label}-${Date.now()}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-describe("buildFileOutline", () => {
-    it("extracts entities from TypeScript without graph", async () => {
-        const dir = makeTmpDir("ts");
-        writeFileSync(join(dir, "sample.ts"), "export function alpha(x: number): number {\n  return x + 1;\n}\n", "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "sample.ts",
-            graph: null,
-        });
-        expect(o.total_lines).toBeGreaterThanOrEqual(3);
-        expect(o.language).toBe("typescript");
-        expect(o.entities.some((e) => e.name === "alpha")).toBe(true);
-        expect(o.imports.length + o.exports.length).toBeGreaterThanOrEqual(1);
-    });
-    it("parses JSON config keys for small .json files", async () => {
-        const dir = makeTmpDir("json");
-        writeFileSync(join(dir, "cfg.json"), JSON.stringify({ foo: 1, bar: { nested: true } }), "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "cfg.json",
-            graph: null,
-        });
-        expect(o.config_keys?.includes("foo")).toBe(true);
-        expect(o.config_keys?.includes("bar")).toBe(true);
-    });
-    it("extracts a Go function without graph", async () => {
-        const dir = makeTmpDir("go");
-        writeFileSync(join(dir, "main.go"), "package main\n\nfunc goAlpha() int { return 1 }\n", "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "main.go",
-            graph: null,
-        });
-        expect(o.language).toBe("go");
-        expect(o.entities.some((e) => e.name === "goAlpha")).toBe(true);
-    });
-    it("extracts a Python function without graph", async () => {
-        const dir = makeTmpDir("py");
-        writeFileSync(join(dir, "mod.py"), "def py_alpha(n):\n    return n + 1\n", "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "mod.py",
-            graph: null,
-        });
-        expect(o.language).toBe("python");
-        expect(o.entities.some((e) => e.name === "py_alpha")).toBe(true);
-    });
-    it("lists markdown headings", async () => {
-        const dir = makeTmpDir("md");
-        writeFileSync(join(dir, "doc.md"), "# Title\n\n## Section\nbody\n", "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "doc.md",
-            graph: null,
-        });
-        expect(o.headings?.some((h) => h.includes("Title"))).toBe(true);
-    });
-    // ─── New FRP-3 tests ──────────────────────────────────────────────────────
-    it("marks exported entities with exported: true", async () => {
-        const dir = makeTmpDir("exported");
-        writeFileSync(join(dir, "lib.ts"), [
-            "export function publicFn(): void {}",
-            "function privateFn(): void {}",
-            "export const PUBLIC_CONST = 1;",
-            "const PRIVATE_CONST = 2;",
-            "export class MyClass {}",
-        ].join("\n"), "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "lib.ts",
-            graph: null,
-        });
-        const publicFn = o.entities.find((e) => e.name === "publicFn");
-        const privateFn = o.entities.find((e) => e.name === "privateFn");
-        const myClass = o.entities.find((e) => e.name === "MyClass");
-        expect(publicFn?.exported).toBe(true);
-        expect(privateFn?.exported).toBe(false);
-        expect(myClass?.exported).toBe(true);
-    });
-    it("provides token_estimate roughly proportional to file size", async () => {
-        const dir = makeTmpDir("token-est");
-        const content = "x".repeat(400); // 400 chars → ~100 tokens at 4 chars/token
-        writeFileSync(join(dir, "small.ts"), content, "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "small.ts",
-            graph: null,
-        });
-        // 400 chars / 4 chars_per_token = 100 tokens
-        expect(o.token_estimate).toBe(100);
-    });
-    it("stable sort: entities with same start line sorted by name", async () => {
-        const dir = makeTmpDir("sort");
-        // Two entities at same line is unusual but can happen with type + const on same line
-        // We'll simulate with a file where AST extracts multiple entities
-        writeFileSync(join(dir, "multi.ts"), [
-            "export function zebra(): void {}",
-            "export function alpha(): void {}",
-            "export function beta(): void {}",
-        ].join("\n"), "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "multi.ts",
-            graph: null,
-        });
-        // Entities should be sorted by start line first
-        for (let i = 1; i < o.entities.length; i++) {
-            const prev = o.entities[i - 1];
-            const curr = o.entities[i];
-            if (prev.lines[0] === curr.lines[0]) {
-                // Same start line → alphabetical
-                expect(prev.name.localeCompare(curr.name)).toBeLessThanOrEqual(0);
-            }
-            else {
-                expect(prev.lines[0]).toBeLessThan(curr.lines[0]);
-            }
-        }
-    });
-    it("all entities have the exported field defined", async () => {
-        const dir = makeTmpDir("exported-all");
-        writeFileSync(join(dir, "mod.ts"), "export function a() {}\nfunction b() {}\nexport class C {}\n", "utf-8");
-        const o = await buildFileOutline({
-            cwd: dir,
-            filePathArg: "mod.ts",
-            graph: null,
-        });
-        for (const entity of o.entities) {
-            expect(typeof entity.exported).toBe("boolean");
-        }
-    });
-});

package/dist/__tests__/file-read-protocol.test.js

@@ -1,188 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { rankEntityMatches, runFileReadForRouter, } from "../tools/coding/file-read-protocol.js";
-function makeTmpDir(label) {
-    const dir = join(tmpdir(), `frp-${label}-${Date.now()}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-describe("runFileReadForRouter", () => {
-    it("returns full content for small files", async () => {
-        const dir = makeTmpDir("small");
-        writeFileSync(join(dir, "a.txt"), "one\ntwo\nthree\n", "utf-8");
-        const r = await runFileReadForRouter({ file_path: "a.txt" }, { cwd: dir, graph: null });
-        expect(typeof r.content).toBe("string");
-        expect(r.content.includes("1\tone")).toBe(true);
-        expect(r._layer6_meta?.gated).toBeUndefined();
-    });
-    it("gates files with >200 lines when no offset/entity", async () => {
-        const dir = makeTmpDir("gate");
-        const lines = Array.from({ length: 205 }, () => "x").join("\n");
-        writeFileSync(join(dir, "big.txt"), lines, "utf-8");
-        const r = await runFileReadForRouter({ file_path: "big.txt" }, { cwd: dir, graph: null });
-        expect(r.content && typeof r.content === "object").toBe(true);
-        const c = r.content;
-        expect(c.gated).toBe(true);
-        expect(r._layer6_meta?.format).toBe("outline");
-        expect(r._layer6_meta?.gated).toBe(true);
-    });
-    it("entity slice includes ±5 line context around the match", async () => {
-        const dir = makeTmpDir("ctx");
-        const prefix = Array.from({ length: 12 }, (_, i) => `// line ${i + 1}`).join("\n");
-        writeFileSync(join(dir, "deep.ts"), `${prefix}\nexport function sliceFn(): number {\n  return 42;\n}\n`, "utf-8");
-        const r = await runFileReadForRouter({ file_path: "deep.ts", entity: "sliceFn" }, { cwd: dir, graph: null });
-        const body = r.content;
-        expect(body.includes("// line 8")).toBe(true);
-        expect(body.includes("sliceFn")).toBe(true);
-        expect(body.includes("(Showing lines")).toBe(true);
-    });
-    it("targets entity by name using AST when graph is null", async () => {
-        const dir = makeTmpDir("ent");
-        writeFileSync(join(dir, "mod.ts"), "// head\nexport function targetFn(): void {\n  return;\n}\n", "utf-8");
-        const r = await runFileReadForRouter({ file_path: "mod.ts", entity: "targetFn" }, { cwd: dir, graph: null });
-        expect(typeof r.content).toBe("string");
-        expect(r.content.includes("targetFn")).toBe(true);
-        expect(r.content.includes("Showing lines")).toBe(true);
-    });
-    it("rejects binary files", async () => {
-        const dir = makeTmpDir("bin");
-        writeFileSync(join(dir, "bin.dat"), Buffer.from([0, 1, 0]));
-        const r = await runFileReadForRouter({ file_path: "bin.dat" }, { cwd: dir, graph: null });
-        expect(r.content && typeof r.content === "object").toBe(true);
-        expect(r.content.error).toMatch(/Binary/);
-    });
-    // ─── Token Budget Tests ─────────────────────────────────────────────────
-    it("adaptive gating: budget=5000 allows 500-line file through without gating", async () => {
-        const dir = makeTmpDir("budget-high");
-        const lines = Array.from({ length: 300 }, (_, i) => `line ${i + 1}`).join("\n");
-        writeFileSync(join(dir, "medium.ts"), lines, "utf-8");
-        const r = await runFileReadForRouter({ file_path: "medium.ts", token_budget: 5000 }, { cwd: dir, graph: null });
-        // With budget=5000, budgetLines = (5000*4)/80 = 250. effectiveGate = max(200, 250) = 250.
-        // File has 300 lines > 250 → still gated
-        // But let's use a higher budget to prove the adaptive gating works
-        const r2 = await runFileReadForRouter({ file_path: "medium.ts", token_budget: 30000 }, { cwd: dir, graph: null });
-        // budget=30000 → budgetLines = (30000*4)/80 = 1500. effectiveGate = max(200, 1500) = 1500.
-        // File has 300 lines < 1500 → NOT gated
-        expect(typeof r2.content).toBe("string");
-        expect(r2._layer6_meta?.gated).toBeUndefined();
-    });
-    it("token budget constrains output line count", async () => {
-        const dir = makeTmpDir("budget-cap");
-        // 150 lines, each ~40 chars → fits in default budget but let's constrain
-        const lines = Array.from({ length: 150 }, (_, i) => `const x${i} = ${i}; // padding here for length`).join("\n");
-        writeFileSync(join(dir, "vars.ts"), lines, "utf-8");
-        const r = await runFileReadForRouter({ file_path: "vars.ts", token_budget: 300 }, { cwd: dir, graph: null });
-        // budget=300 → budgetLines = (300*4)/80 = 15
-        // File has 150 lines, effLimit = min(15, 150) = 15
-        const body = r.content;
-        expect(body.includes("(Showing lines")).toBe(true);
-        // Should only show ~15 lines
-        const outputLines = body.split("\n").filter((l) => /^\d+\t/.test(l));
-        expect(outputLines.length).toBeLessThanOrEqual(20); // some tolerance
-    });
-    it("default behavior unchanged: no token_budget → same as before", async () => {
-        const dir = makeTmpDir("default");
-        const lines = Array.from({ length: 205 }, () => "x").join("\n");
-        writeFileSync(join(dir, "big.txt"), lines, "utf-8");
-        // Default token_budget=2000 → budgetLines=(2000*4)/80=100 → effectiveGate=max(200,100)=200
-        // File has 205 > 200 → gated (same as before)
-        const r = await runFileReadForRouter({ file_path: "big.txt" }, { cwd: dir, graph: null });
-        expect(r.content.gated).toBe(true);
-    });
-    // ─── Ranked Entity Matching Tests ───────────────────────────────────────
-    it("case-insensitive match: 'CompressOutput' finds 'compressOutput'", async () => {
-        const dir = makeTmpDir("case-ins");
-        writeFileSync(join(dir, "fn.ts"), "// top\nexport function compressOutput(): string {\n  return '';\n}\n", "utf-8");
-        const r = await runFileReadForRouter({ file_path: "fn.ts", entity: "CompressOutput" }, { cwd: dir, graph: null });
-        expect(typeof r.content).toBe("string");
-        expect(r.content.includes("compressOutput")).toBe(true);
-    });
-    it("prefix match: 'compress' matches 'compressShellOutput'", async () => {
-        const dir = makeTmpDir("prefix");
-        writeFileSync(join(dir, "fn.ts"), "// filler\nexport function compressShellOutput(): string {\n  return '';\n}\n", "utf-8");
-        const r = await runFileReadForRouter({ file_path: "fn.ts", entity: "compress" }, { cwd: dir, graph: null });
-        expect(typeof r.content).toBe("string");
-        expect(r.content.includes("compressShellOutput")).toBe(true);
-    });
-    it("entity not found on large file: returns outline with suggestions", async () => {
-        const dir = makeTmpDir("not-found");
-        const filler = Array.from({ length: 210 }, (_, i) => `// line ${i}`).join("\n");
-        writeFileSync(join(dir, "big.ts"), `${filler}\nexport function realFunction(): void {}\n`, "utf-8");
-        const r = await runFileReadForRouter({ file_path: "big.ts", entity: "nonExistentThing" }, { cwd: dir, graph: null });
-        const c = r.content;
-        expect(c.gated).toBe(true);
-        expect(c.entity_search).toBeDefined();
-        const search = c.entity_search;
-        expect(search.matched).toBe(false);
-        expect(search.query).toBe("nonExistentThing");
-    });
-    it("provides tokens_estimate in _layer6_meta", async () => {
-        const dir = makeTmpDir("tokens-est");
-        writeFileSync(join(dir, "a.ts"), "const x = 1;\nconst y = 2;\n", "utf-8");
-        const r = await runFileReadForRouter({ file_path: "a.ts" }, { cwd: dir, graph: null });
-        expect(r._layer6_meta?.tokens_estimate).toBeGreaterThan(0);
-        expect(r._layer6_meta?.tokens_estimate).toBeLessThan(100);
-    });
-    it("empty file returns empty content without error", async () => {
-        const dir = makeTmpDir("empty");
-        writeFileSync(join(dir, "empty.ts"), "", "utf-8");
-        const r = await runFileReadForRouter({ file_path: "empty.ts" }, { cwd: dir, graph: null });
-        // Empty file has totalLines=1 (one empty string from split), body may be empty
-        // Should not throw or return error
-        expect(r._layer6_meta?.format).toBe("json");
-    });
-});
-describe("rankEntityMatches", () => {
-    const entities = [
-        { name: "compressShellOutput", start_line: 10, body: "function body" },
-        { name: "compressOutput", start_line: 20, body: "function body" },
-        { name: "decompressInput", start_line: 30, body: "function body" },
-        { name: "CompressOutput", start_line: 40, body: "function body" },
-    ];
-    it("exact match scores 100", () => {
-        const ranked = rankEntityMatches(entities, "compressOutput");
-        expect(ranked[0].score).toBe(100);
-        expect(ranked[0].entity.name).toBe("compressOutput");
-        expect(ranked[0].matchType).toBe("exact");
-    });
-    it("case-insensitive match scores 90", () => {
-        const ranked = rankEntityMatches(entities, "compressoutput");
-        expect(ranked[0].score).toBe(90);
-        expect(ranked[0].entity.name).toBe("compressOutput");
-        expect(ranked[0].matchType).toBe("case_insensitive");
-    });
-    it("prefix match scores 80", () => {
-        const ranked = rankEntityMatches(entities, "compress");
-        expect(ranked[0].score).toBe(80);
-        // Both compressShellOutput and compressOutput start with "compress"
-        // Both get score 80, sort is stable (order depends on input array)
-        expect(ranked[0].matchType).toBe("prefix");
-    });
-    it("camelCase segment match scores 70", () => {
-        const ents = [
-            { name: "compressShellOutput", start_line: 10, body: "fn" },
-            { name: "handleInput", start_line: 20, body: "fn" },
-        ];
-        const ranked = rankEntityMatches(ents, "shell");
-        expect(ranked[0].score).toBe(70);
-        expect(ranked[0].entity.name).toBe("compressShellOutput");
-        expect(ranked[0].matchType).toBe("camelCase_segment");
-    });
-    it("substring match scores between 40-60 based on specificity", () => {
-        const ents = [{ name: "myHandlerForXyz", start_line: 10, body: "fn" }];
-        // "handler" is not a camelCase segment of "myHandlerForXyz" (segments: my, handler, for, xyz)
-        // Actually it IS a segment. Let's use a true substring that isn't a segment.
-        const ents2 = [{ name: "handleAllRequests", start_line: 10, body: "fn" }];
-        // "eAll" is a substring but not a segment
-        const ranked = rankEntityMatches(ents2, "eAll");
-        expect(ranked[0].score).toBeGreaterThanOrEqual(40);
-        expect(ranked[0].score).toBeLessThanOrEqual(60);
-        expect(ranked[0].matchType).toBe("substring");
-    });
-    it("returns empty array when nothing matches", () => {
-        const ranked = rankEntityMatches(entities, "zzzzNotHere");
-        expect(ranked).toHaveLength(0);
-    });
-});

package/dist/__tests__/format-encoder.test.js

@@ -1,233 +0,0 @@
-/**
- * Layer 6 Sprint FE-C — format encoder unit + router integration tests.
- */
-import { describe, expect, it, vi } from "vitest";
-import { QueryRouter } from "../intelligence/query-router.js";
-import { COLUMNAR_LEGEND_TEXT, detectShape, encodeColumnar, escapeColumnarCell, formatToolOutput, isUniformObjectArray, } from "../proxy/format-encoder.js";
-import { createSessionLegendTracker } from "../proxy/session-legend.js";
-describe("detectShape", () => {
-    it("classifies uniform object arrays", () => {
-        expect(detectShape([
-            { a: 1, b: 2 },
-            { b: 3, a: 4 },
-        ])).toBe("uniform-array");
-    });
-    it("classifies heterogeneous arrays", () => {
-        expect(detectShape([{ a: 1 }, { a: 1, b: 2 }])).toBe("heterogeneous");
-        expect(detectShape([1, 2])).toBe("heterogeneous");
-    });
-    it("classifies single objects", () => {
-        expect(detectShape({ x: 1 })).toBe("single-object");
-    });
-});
-describe("isUniformObjectArray", () => {
-    it("returns true when keys match across rows", () => {
-        expect(isUniformObjectArray([
-            { k: "a", n: 1 },
-            { n: 2, k: "b" },
-        ])).toBe(true);
-    });
-    it("returns false when keys differ", () => {
-        expect(isUniformObjectArray([{ k: "a" }, { k: "b", extra: 1 }])).toBe(false);
-    });
-});
-describe("escapeColumnarCell", () => {
-    it("quotes pipes and newlines", () => {
-        expect(escapeColumnarCell("a|b")).toBe('"a|b"');
-        expect(escapeColumnarCell('say "hi"')).toBe('"say ""hi"""');
-        expect(escapeColumnarCell("x\ny")).toBe("x\\ny");
-    });
-    it("renders null as empty", () => {
-        expect(escapeColumnarCell(null)).toBe("");
-        expect(escapeColumnarCell(undefined)).toBe("");
-    });
-});
-describe("encodeColumnar", () => {
-    it("emits _fmt header and aligned rows", () => {
-        const text = encodeColumnar([
-            { name: "x", v: 1 },
-            { name: "y", v: 2 },
-        ], ["name", "v"]);
-        expect(text.startsWith("_fmt:columnar\nname|v\n")).toBe(true);
-        expect(text).toContain("x|1");
-        expect(text).toContain("y|2");
-    });
-});
-describe("formatToolOutput", () => {
-    it("columnar-encodes uniform arrays", () => {
-        const meta = { format: "json" };
-        const out = formatToolOutput("get_callers", [{ k: "a", z: 1 }], meta);
-        expect(typeof out).toBe("string");
-        expect(out).toContain("_fmt:columnar");
-        expect(meta.format).toBe("columnar");
-        expect(meta.columns).toEqual(["k", "z"]);
-    });
-    it("does not format outline payloads", () => {
-        const meta = { format: "outline", gated: true };
-        const payload = [{ a: 1 }];
-        expect(formatToolOutput("file_read", payload, meta)).toBe(payload);
-    });
-});
-describe("formatToolOutput FE-E (legends, tiers)", () => {
-    it("attaches columnar legend once per tracker until invalidated", () => {
-        const legend = createSessionLegendTracker();
-        const metaC = {};
-        formatToolOutput("get_callers", [{ k: "a", z: 1 }], metaC, {
-            legend,
-            tier: "columnar",
-        });
-        expect(metaC.columnar_legend).toBe(COLUMNAR_LEGEND_TEXT);
-        const metaC2 = {};
-        formatToolOutput("get_callers", [{ k: "b", z: 2 }], metaC2, {
-            legend,
-            tier: "columnar",
-        });
-        expect(metaC2.columnar_legend).toBeUndefined();
-    });
-    it("minified tier skips columnar but keeps structured JSON", () => {
-        const meta = {};
-        const out = formatToolOutput("get_callers", [
-            { k: "a", z: 1 },
-            { k: "b", z: 2 },
-        ], meta, { tier: "minified" });
-        expect(Array.isArray(out)).toBe(true);
-        expect(meta.format).toBe("json");
-    });
-    it("expanded tier returns untouched object", () => {
-        const obj = { key: "fn1", kind: "function", name: "doStuff" };
-        const meta = {};
-        const out = formatToolOutput("get_function", obj, meta, {
-            tier: "expanded",
-        });
-        expect(out).toBe(obj);
-        expect(meta.format).toBe("json");
-    });
-});
-describe("performance: columnar encode 500 rows", () => {
-    it("encodes in under 5ms", () => {
-        const row = {
-            key: "k",
-            kind: "function",
-            name: "n",
-            file_path: "f.ts",
-            start_line: 1,
-            signature: "()",
-            body: "x",
-            fan_in: 0,
-            fan_out: 0,
-            risk_level: "normal",
-            community: -1,
-        };
-        const rows = Array.from({ length: 500 }, (_, i) => ({
-            ...row,
-            key: `k${i}`,
-        }));
-        const cols = Object.keys(row).sort();
-        const t0 = performance.now();
-        encodeColumnar(rows, cols);
-        const ms = performance.now() - t0;
-        expect(ms).toBeLessThan(5);
-    });
-});
-function minimalGraphWithCallers(rows) {
-    return {
-        getEntity: vi.fn(),
-        getCallersOf: vi.fn().mockResolvedValue(rows),
-        getCalleesOf: vi.fn().mockResolvedValue([]),
-        searchEntities: vi.fn().mockResolvedValue([]),
-        getImports: vi.fn().mockResolvedValue([]),
-        getBlastRadius: vi.fn().mockReturnValue({
-            direct_callers: 0,
-            direct_callees: 0,
-            transitive_count: 0,
-            transitive_depth: 0,
-            is_chokepoint: false,
-            summary: "",
-        }),
-        getBlastRadiusEntities: vi.fn().mockReturnValue([]),
-        getConventionsForEntity: vi.fn().mockReturnValue([]),
-        getCorrections: vi.fn().mockReturnValue([]),
-        getCommunityForEntity: vi.fn().mockReturnValue(null),
-        getCrossCommunityEdges: vi.fn().mockReturnValue([]),
-        getEntitiesByFile: vi.fn().mockReturnValue([]),
-        queryEntities: vi.fn().mockReturnValue([]),
-        getDriftOverlayEntity: vi.fn().mockReturnValue(null),
-        getDriftSummary: vi
-            .fn()
-            .mockReturnValue({ added: 0, modified: 0, removed: 0, total: 0 }),
-        getCriticalNodes: vi.fn().mockReturnValue([]),
-        getCrossBoundaryLinks: vi.fn().mockReturnValue([]),
-        getRules: vi.fn().mockReturnValue([]),
-        getJustificationsForEntity: vi.fn().mockReturnValue([]),
-        getDriftEntitiesForFile: vi.fn().mockReturnValue([]),
-        db: { run: vi.fn().mockResolvedValue({ rows: [] }) },
-        close: vi.fn(),
-    };
-}
-describe("QueryRouter + FE-C integration", () => {
-    it("get_callers returns columnar text for uniform caller rows", async () => {
-        const row = {
-            key: "caller1",
-            kind: "function",
-            name: "c",
-            file_path: "src/x.ts",
-            start_line: 1,
-            signature: "()",
-            body: "",
-            fan_in: 1,
-            fan_out: 0,
-            risk_level: "normal",
-            community: -1,
-        };
-        const graph = minimalGraphWithCallers([row]);
-        const router = new QueryRouter(graph);
-        const result = await router.execute("get_callers", { key: "fn1" });
-        expect(result._meta.format).toBe("columnar");
-        expect(typeof result.content).toBe("string");
-        expect(result.content).toContain("_fmt:columnar");
-        expect(result._meta.columns?.length).toBeGreaterThan(0);
-    });
-    it("search_code returns columnar for uniform entity rows", async () => {
-        const row = {
-            key: "e1",
-            kind: "function",
-            name: "n",
-            file_path: "a.ts",
-            start_line: 1,
-            signature: "()",
-            body: "",
-            fan_in: 0,
-            fan_out: 0,
-            risk_level: "low",
-            community: 0,
-        };
-        const graph = minimalGraphWithCallers([]);
-        graph.searchEntities.mockResolvedValue([row]);
-        const router = new QueryRouter(graph);
-        const result = await router.execute("search_code", { query: "foo" });
-        expect(result._meta.format).toBe("columnar");
-        expect(result.content.includes("_fmt:columnar")).toBe(true);
-    });
-    it("get_function strips community but preserves body (useful code)", async () => {
-        const graph = minimalGraphWithCallers([]);
-        graph.getEntity.mockResolvedValue({
-            key: "fn1",
-            kind: "function",
-            name: "doStuff",
-            file_path: "src/index.ts",
-            start_line: 10,
-            signature: "()",
-            body: "{}",
-            fan_in: 0,
-            fan_out: 0,
-            risk_level: "normal",
-            community: 0,
-        });
-        const router = new QueryRouter(graph);
-        const result = await router.execute("get_function", { key: "fn1" });
-        const content = result.content;
-        expect(content.key).toBe("fn1");
-        expect(content.body).toBe("{}");
-        expect(content.community).toBeUndefined();
-    });
-});