@unerr-ai/unerr 0.1.0 → 0.1.1

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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,188 @@
+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

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