@sting8k/pi-vcc 0.1.0

package/tests/fixtures.ts

@@ -0,0 +1,61 @@
+import type { Message } from "@mariozechner/pi-ai";
+
+const ts = Date.now();
+const assistBase = {
+  api: "messages" as any,
+  provider: "anthropic" as any,
+  model: "test",
+  usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  timestamp: ts,
+};
+
+export const userMsg = (text: string): Message => ({
+  role: "user",
+  content: text,
+  timestamp: ts,
+});
+
+export const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text }],
+  ...assistBase,
+  stopReason: "stop",
+});
+
+export const assistantWithThinking = (
+  text: string,
+  thinking: string,
+): Message => ({
+  role: "assistant",
+  content: [
+    { type: "thinking", thinking },
+    { type: "text", text },
+  ],
+  ...assistBase,
+  stopReason: "stop",
+});
+
+export const assistantWithToolCall = (
+  name: string,
+  args: Record<string, unknown>,
+): Message => ({
+  role: "assistant",
+  content: [{ type: "toolCall", id: "tc_1", name, arguments: args }],
+  ...assistBase,
+  stopReason: "toolUse",
+});
+
+export const toolResult = (
+  name: string,
+  text: string,
+  isError = false,
+): Message => ({
+  role: "toolResult",
+  toolCallId: "tc_1",
+  toolName: name,
+  content: [{ type: "text", text }],
+  isError,
+  timestamp: ts,
+});
+
+

package/tests/format-recall.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "bun:test";
+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,47 @@
+import { describe, it, expect } from "bun:test";
+import { formatSummary } from "../src/core/format";
+import type { SectionData } from "../src/sections";
+
+const empty: SectionData = {
+  sessionGoal: [], currentState: [], whatWasDone: [],
+  importantFindings: [], filesRead: [], filesModified: [],
+  filesCreated: [], openProblems: [], decisions: [],
+  userPreferences: [], nextSteps: [],
+};
+
+describe("formatSummary", () => {
+  it("returns empty string for all-empty sections", () => {
+    expect(formatSummary(empty)).toBe("");
+  });
+
+  it("formats a single section", () => {
+    const data = { ...empty, sessionGoal: ["Fix login"] };
+    expect(formatSummary(data)).toBe("[Session Goal]\n- Fix login");
+  });
+
+  it("formats files section with subcategories", () => {
+    const data = {
+      ...empty,
+      filesRead: ["a.ts"],
+      filesModified: ["b.ts"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("[Files And Changes]");
+    expect(r).toContain("Read:");
+    expect(r).toContain("  - a.ts");
+    expect(r).toContain("Modified:");
+  });
+
+  it("joins multiple sections with blank line", () => {
+    const data = {
+      ...empty,
+      sessionGoal: ["goal"],
+      nextSteps: ["step 1"],
+    };
+    const r = formatSummary(data);
+    expect(r).toContain("\n\n");
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("[Next Best Steps]");
+  });
+});
+

package/tests/normalize.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "bun:test";
+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" }]);
+  });
+
+  it("normalizes assistant text message", () => {
+    const blocks = normalize([assistantText("done")]);
+    expect(blocks).toEqual([{ kind: "assistant", text: "done" }]);
+  });
+
+  it("normalizes assistant string content", () => {
+    const msg = { ...assistantText("done"), content: "plain text" } as any;
+    expect(normalize([msg])).toEqual([{ kind: "assistant", text: "plain text" }]);
+  });
+
+  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,
+    });
+    expect(blocks[1]).toEqual({ kind: "assistant", text: "result" });
+  });
+
+  it("normalizes tool call", () => {
+    const blocks = normalize([assistantWithToolCall("Read", { path: "a.ts" })]);
+    expect(blocks).toEqual([{
+      kind: "tool_call", name: "Read", args: { path: "a.ts" },
+    }]);
+  });
+
+  it("normalizes tool result", () => {
+    const blocks = normalize([toolResult("Read", "file contents")]);
+    expect(blocks).toEqual([{
+      kind: "tool_result", name: "Read",
+      text: "file contents", isError: false,
+    }]);
+  });
+
+  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" });
+    expect(blocks[1]).toEqual({ kind: "user", text: "[image: image/png]" });
+  });
+
+  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 "bun:test";
+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 = 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/render-entries.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "bun:test";
+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).toStartWith("ERROR");
+  });
+
+  it("truncates long user text", () => {
+    const long = "x".repeat(500);
+    const r = renderMessage(userMsg(long), 0);
+    expect(r.summary.length).toBeLessThanOrEqual(300);
+  });
+});
+

package/tests/report.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "bun:test";
+import { buildCompactReport } from "../src/core/report";
+import {
+  userMsg,
+  assistantText,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("buildCompactReport", () => {
+  it("includes before and after compact metrics", () => {
+    const report = buildCompactReport({
+      messages: [
+        userMsg("Fix login bug in auth.ts"),
+        assistantWithToolCall("Read", { path: "auth.ts" }),
+        toolResult("Read", "function login() {}"),
+        assistantText("Found the root cause in auth.ts.\n1. Fix validation\n2. Run tests"),
+      ],
+    });
+
+    expect(report.summary).toContain("[Session Goal]");
+    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("[Files And Changes]");
+    expect(report.compression.charsBefore).toBeGreaterThan(0);
+    expect(report.recall.probes.length).toBeGreaterThan(0);
+  });
+
+  it("marks recall probe coverage for goal and file queries", () => {
+    const report = buildCompactReport({
+      messages: [
+        userMsg("Investigate timeout in api/server.ts"),
+        assistantWithToolCall("Read", { path: "api/server.ts" }),
+        toolResult("Read", "timeout error in api/server.ts"),
+        assistantText("Confirmed timeout error in api/server.ts.\n- Patch retry handling"),
+      ],
+    });
+
+    const goalProbe = report.recall.probes.find((probe) => probe.label === "goal");
+    const fileProbe = report.recall.probes.find((probe) => probe.label === "file");
+
+    expect(goalProbe).toBeDefined();
+    expect(goalProbe?.sourceText).toContain("Investigate timeout");
+    expect(goalProbe?.summaryMentioned).toBe(true);
+    expect(goalProbe?.recallHits).toBeGreaterThan(0);
+    expect(fileProbe).toBeDefined();
+    expect(fileProbe?.sourceText).toBe("api/server.ts");
+    expect(fileProbe?.summaryMentioned).toBe(true);
+    expect(fileProbe?.recallHits).toBeGreaterThan(0);
+  });
+});

package/tests/sanitize.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "bun:test";
+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");
+  });
+});

package/tests/search-entries.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "bun:test";
+import { searchEntries } from "../src/core/search-entries";
+import type { RenderedEntry } from "../src/core/render-entries";
+
+const entries: RenderedEntry[] = [
+  { index: 0, role: "user", summary: "Fix login bug" },
+  { index: 1, role: "assistant", summary: "Reading auth.ts" },
+  { index: 2, role: "tool_result", summary: "[Read] code here" },
+  { index: 3, role: "assistant", summary: "Found the root cause" },
+];
+
+describe("searchEntries", () => {
+  it("returns all for empty query", () => {
+    expect(searchEntries(entries)).toEqual(entries);
+    expect(searchEntries(entries, "")).toEqual(entries);
+  });
+
+  it("filters by single term", () => {
+    const r = searchEntries(entries, "login");
+    expect(r).toHaveLength(1);
+    expect(r[0].index).toBe(0);
+  });
+
+  it("filters by multiple terms (AND)", () => {
+    const r = searchEntries(entries, "root cause");
+    expect(r).toHaveLength(1);
+    expect(r[0].index).toBe(3);
+  });
+
+  it("returns empty for no match", () => {
+    expect(searchEntries(entries, "xyz123")).toEqual([]);
+  });
+});

package/tests/support/load-session.ts

@@ -0,0 +1,23 @@
+import { buildSessionContext, loadEntriesFromFile } from "../../node_modules/@mariozechner/pi-coding-agent/dist/core/session-manager.js";
+import type { Message } from "@mariozechner/pi-ai";
+
+export interface LoadedSession {
+  messageCount: number;
+  skippedCount: number;
+  messages: Message[];
+}
+
+export const loadSessionMessages = (file: string): LoadedSession => {
+  const entries = loadEntriesFromFile(file);
+  const sessionEntries = entries.filter((entry) => entry.type !== "header");
+  const context = buildSessionContext(sessionEntries as any);
+  const messages = (context.messages as any[]).filter(
+    (msg): msg is Message =>
+      msg && typeof msg.role === "string" && "content" in msg,
+  );
+  return {
+    messageCount: messages.length,
+    skippedCount: context.messages.length - messages.length,
+    messages,
+  };
+};

package/tests/support/real-sessions.ts

@@ -0,0 +1,51 @@
+import { mkdir, mkdtemp, copyFile, chmod, readdir, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, basename } from "node:path";
+
+const SESSION_ROOT = join(process.env.HOME ?? "", ".pi/agent/sessions");
+
+export interface SessionSample {
+  source: string;
+  copy: string;
+  size: number;
+  mtimeMs: number;
+}
+
+const walk = async (dir: string): Promise<string[]> => {
+  const names = await readdir(dir, { withFileTypes: true });
+  const out: string[] = [];
+  for (const name of names) {
+    const path = join(dir, name.name);
+    if (name.isDirectory()) out.push(...await walk(path));
+    else if (name.isFile() && path.endsWith(".jsonl")) out.push(path);
+  }
+  return out;
+};
+
+const pickLargest = async (limit: number): Promise<string[]> => {
+  const files = await walk(SESSION_ROOT);
+  const sized = await Promise.all(
+    files.map(async (file) => ({ file, size: (await stat(file)).size })),
+  );
+  return sized.sort((a, b) => b.size - a.size).slice(0, limit).map((x) => x.file);
+};
+
+export const prepareSessionSamples = async (limit = 2): Promise<SessionSample[]> => {
+  const selected = await pickLargest(limit);
+  const dir = await mkdtemp(join(tmpdir(), "pi-vcc-sessions-"));
+  await mkdir(dir, { recursive: true });
+  const samples: SessionSample[] = [];
+  for (const source of selected) {
+    const srcStat = await stat(source);
+    const copy = join(dir, basename(source));
+    await copyFile(source, copy);
+    await chmod(copy, 0o444);
+    samples.push({ source, copy, size: srcStat.size, mtimeMs: srcStat.mtimeMs });
+  }
+  return samples;
+};
+
+export const readSourceStat = async (sample: SessionSample) => {
+  const s = await stat(sample.source);
+  return { size: s.size, mtimeMs: s.mtimeMs };
+};