pi-vcc 0.4.0

package/tests/format-recall.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { formatRecallOutput } from "../src/core/format-recall";
+import type { RenderedEntry } from "../src/core/render-entries";
+
+describe("formatRecallOutput", () => {
+  it("shows no-match message with query", () => {
+    const r = formatRecallOutput([], "xyz");
+    expect(r).toContain('No matches for "xyz"');
+  });
+
+  it("shows no-entries message without query", () => {
+    expect(formatRecallOutput([])).toContain("No entries");
+  });
+
+  it("formats entries with index and role", () => {
+    const entries: RenderedEntry[] = [
+      { index: 0, role: "user", summary: "hello" },
+    ];
+    const r = formatRecallOutput(entries);
+    expect(r).toContain("#0 [user] hello");
+  });
+
+  it("shows match count with query", () => {
+    const entries: RenderedEntry[] = [
+      { index: 2, role: "assistant", summary: "done" },
+    ];
+    const r = formatRecallOutput(entries, "done");
+    expect(r).toContain('Found 1 matches for "done"');
+  });
+});

package/tests/format.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { formatSummary } from "../src/core/format";
+import type { SectionData } from "../src/sections";
+
+const empty: SectionData = {
+  sessionGoal: [],
+  outstandingContext: [],
+  filesAndChanges: [],
+  commits: [],
+  references: [],
+  keySignals: [],
+  userPreferences: [],
+  briefTranscript: "",
+  transcriptEntries: [],
+};
+
+describe("formatSummary", () => {
+  it("returns empty string for all-empty sections", () => {
+    expect(formatSummary(empty)).toBe("");
+  });
+
+  it("formats a single header section", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["fix auth bug"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("- fix auth bug");
+  });
+
+  it("separates header and brief transcript with ---", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["goal"],
+      briefTranscript: "[user]\ndo something",
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("---");
+    expect(r).toContain("[user]\ndo something");
+  });
+
+  it("renders brief transcript alone when no header sections", () => {
+    const data = {
+      ...empty,
+      briefTranscript: "[user]\nhi\n\n[assistant]\nhello",
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[user]\nhi\n\n[assistant]\nhello");
+  });
+
+  it("joins multiple header sections with blank line", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["goal"],
+      outstandingContext: ["blocker"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("[Outstanding Context]");
+    expect(r).toContain("\n\n");
+  });
+
+  it("renders References section after Commits", () => {
+    const data = {
+      ...empty,
+      commits: ["abc1234: fix bug"],
+      references: ["URL: https://example.com", "GitHub: #42"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Commits]");
+    expect(r).toContain("[References]");
+    expect(r).toContain("- URL: https://example.com");
+    expect(r).toContain("- GitHub: #42");
+    // References should appear after Commits in output
+    const commitsIdx = r.indexOf("[Commits]");
+    const refsIdx = r.indexOf("[References]");
+    expect(refsIdx).toBeGreaterThan(commitsIdx);
+  });
+
+  it("skips References section when empty", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["goal"],
+      references: [],
+    };
+    const r = formatSummary(data);
+    expect(r).not.toContain("[References]");
+  });
+});

package/tests/lineage.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { getActiveLineageEntryIds } from "../src/core/lineage";
+
+describe("getActiveLineageEntryIds", () => {
+  it("returns IDs from active branch", () => {
+    const ids = getActiveLineageEntryIds({
+      getBranch: () => [{ id: "a" }, { id: "b" }, { id: "c" }],
+    });
+    expect([...ids]).toEqual(["a", "b", "c"]);
+  });
+
+  it("falls back to getEntries when getBranch throws", () => {
+    const ids = getActiveLineageEntryIds({
+      getBranch: () => {
+        throw new Error("boom");
+      },
+      getEntries: () => [{ id: "x" }, { id: "y" }],
+    });
+    expect([...ids]).toEqual(["x", "y"]);
+  });
+
+  it("returns empty set when both branch and entries are unavailable", () => {
+    const ids = getActiveLineageEntryIds({
+      getBranch: () => {
+        throw new Error("boom");
+      },
+      getEntries: () => {
+        throw new Error("boom2");
+      },
+    });
+    expect(ids.size).toBe(0);
+  });
+});

package/tests/load-messages.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { loadAllMessages } from "../src/core/load-messages";
+
+describe("loadAllMessages", () => {
+  it("loads all message entries when no lineage filter is provided", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-all-"));
+    const file = join(dir, "session.jsonl");
+    try {
+      const lines = [
+        JSON.stringify({ type: "session", id: "s1" }),
+        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
+        JSON.stringify({ type: "custom", id: "c1", customType: "x", data: {} }),
+        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
+        JSON.stringify({ type: "message", id: "m3", message: { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] } }),
+      ];
+      writeFileSync(file, lines.join("\n") + "\n", "utf8");
+
+      const loaded = await loadAllMessages(file, false);
+      expect(loaded.rendered).toHaveLength(3);
+      expect(loaded.rawMessages).toHaveLength(3);
+      expect(loaded.entryIds).toEqual(["m1", "m2", "m3"]);
+      expect(loaded.rendered.map((e) => e.index)).toEqual([0, 1, 2]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("filters messages by allowed lineage entry IDs and preserves original message index", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-vcc-load-filter-"));
+    const file = join(dir, "session.jsonl");
+    try {
+      const lines = [
+        JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "u1" } }),
+        JSON.stringify({ type: "message", id: "m2", message: { role: "assistant", content: [{ type: "text", text: "a1" }] } }),
+        JSON.stringify({ type: "message", id: "m3", message: { role: "user", content: "u2" } }),
+      ];
+      writeFileSync(file, lines.join("\n") + "\n", "utf8");
+
+      const loaded = await loadAllMessages(file, false, new Set(["m2"]));
+      expect(loaded.rendered).toHaveLength(1);
+      expect(loaded.rawMessages).toHaveLength(1);
+      expect(loaded.entryIds).toEqual(["m2"]);
+      expect(loaded.rendered[0].index).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/normalize.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import { normalize } from "../src/core/normalize";
+import {
+  userMsg,
+  assistantText,
+  assistantWithThinking,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("normalize", () => {
+  it("returns empty for empty input", () => {
+    expect(normalize([])).toEqual([]);
+  });
+
+  it("normalizes user message (string content)", () => {
+    const blocks = normalize([userMsg("fix the bug")]);
+    expect(blocks).toEqual([{ kind: "user", text: "fix the bug", sourceIndex: 0 }]);
+  });
+
+  it("normalizes assistant text message", () => {
+    const blocks = normalize([assistantText("done")]);
+    expect(blocks).toEqual([{ kind: "assistant", text: "done", sourceIndex: 0 }]);
+  });
+
+  it("normalizes assistant string content", () => {
+    const msg = { ...assistantText("done"), content: "plain text" } as any;
+    expect(normalize([msg])).toEqual([{ kind: "assistant", text: "plain text", sourceIndex: 0 }]);
+  });
+
+  it("splits assistant thinking + text", () => {
+    const blocks = normalize([assistantWithThinking("result", "hmm")]);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({
+      kind: "thinking", text: "hmm", redacted: false, sourceIndex: 0,
+    });
+    expect(blocks[1]).toEqual({ kind: "assistant", text: "result", sourceIndex: 0 });
+  });
+
+  it("normalizes tool call", () => {
+    const blocks = normalize([assistantWithToolCall("Read", { path: "a.ts" })]);
+    expect(blocks).toEqual([{
+      kind: "tool_call", name: "Read", args: { path: "a.ts" }, sourceIndex: 0,
+    }]);
+  });
+
+  it("normalizes tool result", () => {
+    const blocks = normalize([toolResult("Read", "file contents")]);
+    expect(blocks).toEqual([{
+      kind: "tool_result", name: "Read",
+      text: "file contents", isError: false, sourceIndex: 0,
+    }]);
+  });
+
+  it("normalizes error tool result", () => {
+    const blocks = normalize([toolResult("Edit", "not found", true)]);
+    expect(blocks[0]).toMatchObject({
+      kind: "tool_result", isError: true,
+    });
+  });
+
+  it("handles mixed message sequence", () => {
+    const blocks = normalize([
+      userMsg("fix it"),
+      assistantWithToolCall("Read", { path: "x.ts" }),
+      toolResult("Read", "code"),
+      assistantText("done"),
+    ]);
+    expect(blocks).toHaveLength(4);
+    expect(blocks.map((b) => b.kind)).toEqual([
+      "user", "tool_call", "tool_result", "assistant",
+    ]);
+  });
+
+  it("produces image placeholder for user image content", () => {
+    const msg = {
+      role: "user" as const,
+      content: [
+        { type: "text" as const, text: "look at this" },
+        { type: "image" as const, data: "abc", mimeType: "image/png" },
+      ],
+      timestamp: Date.now(),
+    };
+    const blocks = normalize([msg]);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ kind: "user", text: "look at this", sourceIndex: 0 });
+    expect(blocks[1]).toEqual({ kind: "user", text: "[image: image/png]", sourceIndex: 0 });
+  });
+
+  it("skips unknown message roles gracefully", () => {
+    const weird = { role: "bashExecution", command: "ls", output: "files", exitCode: 0 } as any;
+    const blocks = normalize([weird]);
+    expect(blocks).toEqual([]);
+  });
+});
+
+

package/tests/real-sessions.test.ts

@@ -0,0 +1,38 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { buildCompactReport } from "../src/core/report";
+import { prepareSessionSamples, readSourceStat, type SessionSample } from "./support/real-sessions";
+import { loadSessionMessages } from "./support/load-session";
+
+let samples: SessionSample[] = [];
+
+beforeAll(async () => {
+  samples = await prepareSessionSamples(2);
+});
+
+describe("real session integration", () => {
+  it("compiles copied large sessions without mutating originals", async () => {
+    for (const sample of samples) {
+      const before = await readSourceStat(sample);
+      const loaded = loadSessionMessages(sample.copy);
+      const report = await buildCompactReport({ messages: loaded.messages });
+      const after = await readSourceStat(sample);
+
+      expect(loaded.messageCount).toBeGreaterThan(0);
+      expect(loaded.skippedCount).toBeGreaterThanOrEqual(0);
+      expect(report.summary.length).toBeGreaterThan(0);
+      expect(report.summary).toContain("[");
+      expect(report.before.preview.length).toBeGreaterThan(0);
+      expect(report.after.summaryPreview.length).toBeGreaterThan(0);
+      expect(report.compression.charsBefore).toBeGreaterThan(0);
+      expect(report.recall.probes.length).toBeGreaterThan(0);
+      expect(after).toEqual(before);
+    }
+  });
+
+  it("uses read-only copied fixtures", () => {
+    for (const sample of samples) {
+      expect(sample.copy).not.toBe(sample.source);
+      expect(sample.copy.includes("pi-vcc-sessions-")).toBe(true);
+    }
+  });
+});

package/tests/recall-expand.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { invalidExpandIndices } from "../src/tools/recall";
+
+describe("invalidExpandIndices", () => {
+  it("returns indices that are not in available lineage index set", () => {
+    const available = new Set([0, 2, 5]);
+    expect(invalidExpandIndices([0, 2], available)).toEqual([]);
+    expect(invalidExpandIndices([1, 2, 7], available)).toEqual([1, 7]);
+  });
+
+  it("rejects non-integer indices", () => {
+    const available = new Set([0, 1, 2]);
+    expect(invalidExpandIndices([1.5, 2], available)).toEqual([1.5]);
+  });
+});

package/tests/recall-scope.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { normalizeRecallScope, parseRecallScope } from "../src/core/recall-scope";
+
+describe("normalizeRecallScope", () => {
+  it("defaults to active lineage", () => {
+    expect(normalizeRecallScope()).toBe("lineage");
+    expect(normalizeRecallScope("lineage")).toBe("lineage");
+    expect(normalizeRecallScope("unknown")).toBe("lineage");
+    expect(normalizeRecallScope(123)).toBe("lineage");
+  });
+
+  it("accepts all scope", () => {
+    expect(normalizeRecallScope("all")).toBe("all");
+    expect(normalizeRecallScope("ALL")).toBe("all");
+  });
+});
+
+describe("parseRecallScope", () => {
+  it("removes scope token from command text", () => {
+    expect(parseRecallScope("license scope:all page:2")).toEqual({
+      scope: "all",
+      text: "license page:2",
+    });
+  });
+
+  it("defaults to lineage when no scope token is present", () => {
+    expect(parseRecallScope("license page:2")).toEqual({
+      scope: "lineage",
+      text: "license page:2",
+    });
+  });
+});

package/tests/recall-tool-scope.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { registerRecallTool } from "../src/tools/recall";
+
+const makeSession = () => {
+  const dir = mkdtempSync(join(tmpdir(), "pi-vcc-recall-scope-"));
+  const file = join(dir, "session.jsonl");
+  const lines = [
+    JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "active lineage token" } }),
+    JSON.stringify({ type: "message", id: "m2", message: { role: "user", content: "off lineage secret" } }),
+  ];
+  writeFileSync(file, lines.join("\n") + "\n", "utf8");
+  return { dir, file };
+};
+
+const register = () => {
+  let tool: any;
+  registerRecallTool({ registerTool: (t: any) => { tool = t; } } as any);
+  return tool;
+};
+
+const invoke = async (tool: any, file: string, params: Record<string, unknown>) => {
+  const result = await tool.execute("tool-call", params, undefined, undefined, {
+    sessionManager: {
+      getSessionFile: () => file,
+      getBranch: () => [{ id: "m1" }],
+      getEntries: () => [{ id: "m1" }, { id: "m2" }],
+    },
+  });
+  return result.content[0].text as string;
+};
+
+describe("vcc_recall scope", () => {
+  it("defaults to active lineage and opts into all-session search explicitly", async () => {
+    const { dir, file } = makeSession();
+    try {
+      const tool = register();
+
+      const lineage = await invoke(tool, file, { query: "secret" });
+      expect(lineage).toContain("No matches");
+
+      const all = await invoke(tool, file, { query: "secret", scope: "all" });
+      expect(all).toContain("scope: all");
+      expect(all).toContain("off lineage secret");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps expand strict by default but allows off-lineage expand with scope all", async () => {
+    const { dir, file } = makeSession();
+    try {
+      const tool = register();
+
+      const lineage = await invoke(tool, file, { expand: [1] });
+      expect(lineage).toContain("Cannot expand indices outside active lineage: 1");
+
+      const all = await invoke(tool, file, { expand: [1], scope: "all" });
+      expect(all).toContain("Scope: all");
+      expect(all).toContain("#1 [user] off lineage secret");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/render-entries.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest";
+import { renderMessage } from "../src/core/render-entries";
+import type { Message } from "@mariozechner/pi-ai";
+import { userMsg, assistantText, assistantWithToolCall, toolResult } from "./fixtures";
+
+describe("renderMessage", () => {
+  it("renders user message", () => {
+    const r = renderMessage(userMsg("hello"), 0);
+    expect(r).toEqual({ index: 0, role: "user", summary: "hello" });
+  });
+
+  it("renders assistant text", () => {
+    const r = renderMessage(assistantText("done"), 1);
+    expect(r.role).toBe("assistant");
+    expect(r.summary).toBe("done");
+  });
+
+  it("renders tool result", () => {
+    const r = renderMessage(toolResult("Read", "file contents"), 2);
+    expect(r.role).toBe("tool_result");
+    expect(r.summary).toContain("[Read]");
+  });
+
+  it("renders tool call arguments with values", () => {
+    const r = renderMessage(assistantWithToolCall("Read", { path: "a.ts" }), 2);
+    expect(r.summary).toContain("Read(path=a.ts)");
+  });
+
+  it("renders error tool result with prefix", () => {
+    const r = renderMessage(toolResult("bash", "not found", true), 3);
+    expect(r.summary.startsWith("ERROR")).toBe(true);
+  });
+
+  it("truncates long user text", () => {
+    const long = "x".repeat(500);
+    const r = renderMessage(userMsg(long), 0);
+    expect(r.summary.length).toBeLessThanOrEqual(300);
+  });
+
+  it("renders bashExecution message", () => {
+    const msg = { role: "bashExecution", command: "ls -la", output: "total 0\n" } as any;
+    const r = renderMessage(msg, 5);
+    expect(r.role).toBe("bash");
+    expect(r.summary).toContain("$ ls -la");
+    expect(r.summary).toContain("total 0");
+  });
+
+  it("renders bashExecution with missing output", () => {
+    const msg = { role: "bashExecution", command: "exit 1" } as any;
+    const r = renderMessage(msg, 6);
+    expect(r.role).toBe("bash");
+    expect(r.summary).toContain("$ exit 1");
+  });
+
+  it("handles message with undefined content", () => {
+    const msg = { role: "assistant", content: undefined } as any;
+    const r = renderMessage(msg, 3);
+    expect(r.role).toBe("assistant");
+    expect(r.summary).toBe("");
+  });
+});
+

package/tests/report.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { buildCompactReport } from "../src/core/report";
+import {
+  userMsg,
+  assistantText,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("buildCompactReport", () => {
+  it("includes before and after compact metrics", async () => {
+    const report = await buildCompactReport({
+      messages: [
+        userMsg("Fix login bug in auth.ts"),
+        assistantWithToolCall("Read", { path: "auth.ts" }),
+        toolResult("Read", "const x = 1;"),
+        assistantText("Found the root cause in auth.ts.\n1. Fix validation\n2. Run tests"),
+      ],
+    });
+    expect(report.before.messageCount).toBe(4);
+    expect(report.before.roleCounts.user).toBe(1);
+    expect(report.before.topFiles).toContain("auth.ts");
+    expect(report.before.preview).toContain("Fix login bug in auth.ts");
+    expect(report.after.sectionCount).toBeGreaterThan(0);
+    expect(report.after.summaryPreview).toContain("[Session Goal]");
+    expect(report.after.summaryPreview).toContain('* Read "auth.ts"');
+    expect(report.after.briefTranscriptLines).toBeGreaterThan(0);
+    expect(report.compression.ratio).toBeGreaterThan(0);
+  });
+
+  it("marks recall probe coverage for goal and file queries", async () => {
+    const report = await buildCompactReport({
+      messages: [
+        userMsg("Fix login bug in auth.ts"),
+        assistantWithToolCall("Read", { path: "auth.ts" }),
+        toolResult("Read", "code content"),
+        assistantText("Found the root cause"),
+      ],
+    });
+    expect(report.recall.probes.length).toBeGreaterThanOrEqual(1);
+    const goalProbe = report.recall.probes.find((p) => p.label === "goal");
+    expect(goalProbe?.summaryMentioned).toBe(true);
+  });
+});

package/tests/sanitize.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { sanitize } from "../src/core/sanitize";
+
+describe("sanitize", () => {
+  it("strips ANSI escape codes", () => {
+    expect(sanitize("\x1b[31mred\x1b[0m")).toBe("red");
+  });
+
+  it("normalizes CRLF to LF", () => {
+    expect(sanitize("a\r\nb\r\n")).toBe("a\nb\n");
+  });
+
+  it("strips bare CR", () => {
+    expect(sanitize("a\rb")).toBe("a\nb");
+  });
+
+  it("strips control characters but preserves newlines and tabs", () => {
+    expect(sanitize("a\x00b\tc\nd")).toBe("ab\tc\nd");
+  });
+
+  it("passes clean text unchanged", () => {
+    expect(sanitize("hello world")).toBe("hello world");
+  });
+});