@monotykamary/pi-vcc 0.4.0 → 0.4.1

package/tests/brief.test.ts

@@ -1,215 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { compileBrief } from "../src/core/brief";
-import type { NormalizedBlock } from "../src/types";
-
-describe("compileBrief", () => {
-  it("returns empty string for no blocks", () => {
-    expect(compileBrief([])).toBe("");
-  });
-
-  it("renders user and assistant text", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "fix auth bug" },
-      { kind: "assistant", text: "Let me look at the auth module." },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("[user]");
-    expect(r).toContain("fix auth bug");
-    expect(r).toContain("[assistant]");
-    expect(r).toContain("Let me look at the auth module.");
-  });
-
-  it("renders bash commands as user actions", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "npm test", output: "FAIL noisy output", exitCode: 1, sourceIndex: 2 },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("[user]\n$ npm test (#2)");
-    expect(r).not.toContain("FAIL noisy output");
-  });
-
-  it("strips filler prefixes but preserves meaningful lead-ins", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Okay, I found the root cause." },
-      { kind: "assistant", text: "Actually, the issue is in middleware." },
-      { kind: "assistant", text: "Let me check the logs." },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("I found the root cause.");
-    expect(r).toContain("the issue is in middleware.");
-    expect(r).toContain("Let me check the logs.");
-  });
-
-  it("collapses tool calls to one-liners under [assistant]", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Let me check." },
-      { kind: "tool_call", name: "Read", args: { file_path: "auth.ts" } },
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts" } },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain('* Read "auth.ts"');
-    expect(r).toContain('* Edit "auth.ts"');
-    // Should merge into single [assistant] section
-    const matches = r.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  it("hides non-error tool results", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "Read", text: "const x = 1;\nconst y = 2;\n// lots of code", isError: false },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toBe("");
-  });
-
-  it("shows tool errors with first line", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "bash", text: "FAIL auth.test.ts\nexpected 200 got 401", isError: true },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("[tool_error] bash");
-    expect(r).toContain("FAIL auth.test.ts");
-  });
-
-  it("hides thinking blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "thinking", text: "Let me think about this...", redacted: false },
-      { kind: "assistant", text: "Here's what I found." },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).not.toContain("think");
-    expect(r).toContain("Here's what I found.");
-  });
-
-  it("merges adjacent assistant sections", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "First part." },
-      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
-      // No user/tool_result between these — should merge
-      { kind: "assistant", text: "Second part." },
-      { kind: "tool_call", name: "Read", args: { file_path: "b.ts" } },
-    ];
-    const r = compileBrief(blocks);
-    const matches = r.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  it("does NOT merge assistant after user", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "First." },
-      { kind: "user", text: "Next task." },
-      { kind: "assistant", text: "Second." },
-    ];
-    const r = compileBrief(blocks);
-    const matches = r.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(2);
-  });
-
-  it("truncates long user text", () => {
-    const longText = Array.from({ length: 300 }, (_, i) => `word${i}`).join(" ");
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: longText },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("(truncated)");
-    expect(r).not.toContain("word299");
-  });
-
-  it("truncates long assistant text", () => {
-    const longText = Array.from({ length: 300 }, (_, i) => `word${i}`).join(" ");
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: longText },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("(truncated)");
-    expect(r).not.toContain("word299");
-  });
-
-  it("renders a realistic conversation flow", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "fix the login bug" },
-      { kind: "thinking", text: "I need to check...", redacted: false },
-      { kind: "assistant", text: "Let me investigate." },
-      { kind: "tool_call", name: "Read", args: { file_path: "login.ts" } },
-      { kind: "tool_result", name: "Read", text: "export function login() { ... }", isError: false },
-      { kind: "tool_call", name: "bash", args: { command: "npm test" } },
-      { kind: "tool_result", name: "bash", text: "FAIL: login test\nExpected true, got false", isError: true },
-      { kind: "assistant", text: "The test is failing because..." },
-      { kind: "tool_call", name: "Edit", args: { file_path: "login.ts" } },
-      { kind: "tool_result", name: "Edit", text: "File edited successfully", isError: false },
-      { kind: "user", text: "test lại đi" },
-      { kind: "assistant", text: "Running tests again." },
-      { kind: "tool_call", name: "bash", args: { command: "npm test" } },
-      { kind: "tool_result", name: "bash", text: "All tests passed", isError: false },
-    ];
-    const r = compileBrief(blocks);
-
-    // Check structure
-    expect(r).toContain("[user]\nfix the login bug");
-    expect(r).toContain('[assistant]\nLet me investigate.\n* Read "login.ts"');
-    expect(r).toContain("[tool_error] bash\nFAIL: login test");
-    expect(r).toContain('[assistant]\nThe test is failing because...\n* Edit "login.ts"');
-    expect(r).toContain("[user]\ntest lại đi");
-    expect(r).toContain('[assistant]\nRunning tests again.\n* bash "npm test"');
-
-    // Hidden content
-    expect(r).not.toContain("think");
-    expect(r).not.toContain("export function login");
-    expect(r).not.toContain("File edited successfully");
-    expect(r).not.toContain("All tests passed");
-  });
-
-  // ── noise filtering tests (aligned with VCC) ──
-
-
-
-
-
-
-
-
-
-  it("suppresses blank lines between consecutive tool-only sections", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Checking files." },
-      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
-      { kind: "tool_result", name: "Read", text: "...", isError: false },
-      // tool_result hidden → next tool_call starts new assistant section
-      // but since both are tool-only, no blank line between
-      { kind: "tool_call", name: "Read", args: { file_path: "b.ts" } },
-      { kind: "tool_result", name: "Read", text: "...", isError: false },
-    ];
-    const r = compileBrief(blocks);
-    // The first assistant section has text + tool, so it's NOT tool-only
-    // The second would be tool-only but merges into the first (adjacent assistant)
-    // So all under one [assistant]
-    expect(r.match(/\[assistant\]/g)?.length).toBe(1);
-  });
-
-  it("caps tool calls per [assistant] turn at 8 (keep tail)", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Working." },
-    ];
-    for (let i = 1; i <= 12; i++) {
-      blocks.push({ kind: "tool_call", name: "bash", args: { command: `echo ${i}` } });
-    }
-    const r = compileBrief(blocks);
-    expect(r).toContain("(4 earlier tool-call entries omitted)");
-    // Last 8 (5..12) kept; first 4 dropped
-    expect(r).not.toContain("echo 1\"");
-    expect(r).not.toContain("echo 4\"");
-    expect(r).toContain("echo 5");
-    expect(r).toContain("echo 12");
-  });
-
-  it("does not cap when tool calls per turn <= 8", () => {
-    const blocks: NormalizedBlock[] = [{ kind: "assistant", text: "ok" }];
-    for (let i = 1; i <= 8; i++) {
-      blocks.push({ kind: "tool_call", name: "bash", args: { command: `c${i}` } });
-    }
-    const r = compileBrief(blocks);
-    expect(r).not.toContain("entries omitted");
-    expect(r).toContain("c1");
-    expect(r).toContain("c8");
-  });
-});

package/tests/build-sections.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { buildSections } from "../src/core/build-sections";
-import type { NormalizedBlock } from "../src/types";
-
-describe("buildSections", () => {
-  it("returns all-empty for no blocks", () => {
-    const r = buildSections({ blocks: [] });
-    expect(r.sessionGoal).toEqual([]);
-    expect(r.outstandingContext).toEqual([]);
-    expect(r.briefTranscript).toBe("");
-  });
-
-  it("populates sections from realistic blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "Fix the auth bug" },
-      { kind: "tool_call", name: "Read", args: { file_path: "auth.ts" } },
-      { kind: "tool_result", name: "Read", text: "const x = 1;", isError: false },
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts" } },
-      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
-      { kind: "assistant", text: "- run tests next" },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.sessionGoal).toContain("Fix the auth bug");
-    expect(r.briefTranscript).toContain('[user]');
-    expect(r.briefTranscript).toContain('* Read "auth.ts"');
-    expect(r.briefTranscript).toContain('* Edit "auth.ts"');
-  });
-
-  it("captures outstanding context from errors", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "bash", text: "FAIL: test broken\ndetails here", isError: true },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.outstandingContext.length).toBeGreaterThan(0);
-    expect(r.outstandingContext[0]).toContain("FAIL");
-  });
-
-  it("brief transcript hides tool results but shows errors", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "Read", text: "lots of code here ...", isError: false },
-      { kind: "tool_result", name: "bash", text: "Command not found", isError: true },
-    ];
-    const r = buildSections({ blocks });
-    expect(r.briefTranscript).not.toContain("lots of code");
-    expect(r.briefTranscript).toContain("[tool_error] bash");
-    expect(r.briefTranscript).toContain("Command not found");
-  });
-
-  it("brief transcript merges adjacent assistant sections", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Part one." },
-      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
-      { kind: "assistant", text: "Part two." },
-    ];
-    const r = buildSections({ blocks });
-    const matches = r.briefTranscript.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(1);
-  });
-});

package/tests/compile.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { compile } from "../src/core/summarize";
-import {
-  userMsg,
-  assistantText,
-  assistantWithToolCall,
-  toolResult,
-} from "./fixtures";
-
-describe("compile", () => {
-  it("returns empty string for no messages", () => {
-    expect(compile({ messages: [] })).toBe("");
-  });
-
-  it("produces hybrid output with header + brief transcript", () => {
-    const r = compile({
-      messages: [
-        userMsg("Fix login bug"),
-        assistantWithToolCall("Read", { path: "auth.ts" }),
-        assistantText("Found the issue.\n1. Fix validation"),
-      ],
-    });
-    expect(r).toContain("[Session Goal]");
-    expect(r).toContain("Fix login bug");
-    expect(r).toContain("---");
-    expect(r).toContain("[user]\nFix login bug");
-    expect(r).toContain('* Read "auth.ts"');
-    expect(r).toContain("Found the issue.");
-  });
-
-  it("merges previous summary goals", () => {
-    const r = compile({
-      messages: [userMsg("New task")],
-      previousSummary: "[Session Goal]\n- Original goal\n\n---\n\n[user]\nOriginal goal",
-    });
-    expect(r).toContain("- Original goal");
-    expect(r).toContain("- New task");
-  });
-
-  it("appends brief transcript on merge", () => {
-    const previousSummary = [
-      "[Session Goal]\n- Original goal",
-      "---",
-      "[user]\nOriginal goal\n\n[assistant]\n* Read \"old.ts\"",
-    ].join("\n\n");
-    const r = compile({
-      previousSummary,
-      messages: [
-        userMsg("Next step"),
-        assistantWithToolCall("Read", { path: "new.ts" }),
-      ],
-    });
-    expect(r).toContain('* Read "old.ts"');
-    expect(r).toContain('* Read "new.ts"');
-    expect(r).toContain("Next step");
-  });
-
-  it("outstanding context is volatile (fresh only)", () => {
-    const previousSummary = "[Outstanding Context]\n- old blocker\n\n---\n\n[user]\nhi";
-    const r = compile({
-      previousSummary,
-      messages: [userMsg("continue")],
-    });
-    expect(r).not.toContain("old blocker");
-  });
-
-  it("caps long brief transcript with rolling window", () => {
-    // Build a very long previous transcript
-    const longTranscript = Array.from({ length: 200 }, (_, i) =>
-      `[user]\nmessage ${i}`
-    ).join("\n\n");
-    const previousSummary = `[Session Goal]\n- goal\n\n---\n\n${longTranscript}`;
-    const r = compile({
-      previousSummary,
-      messages: [userMsg("latest")],
-    });
-    expect(r).toContain("earlier lines omitted");
-    expect(r).toContain("latest");
-  });
-
-  it("wraps final output including recall note", () => {
-    const r = compile({
-      messages: [userMsg("check final summary wrapping")],
-    });
-    const maxLineLength = Math.max(...r.split("\n").map((line) => line.length));
-    expect(r).toContain("vcc_recall");
-    expect(maxLineLength).toBeLessThanOrEqual(120);
-  });
-});

package/tests/content.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { textOf, thinkingOf, clip, firstLine } from "../src/core/content";
-
-describe("textOf", () => {
-  it("returns empty string for undefined content", () => {
-    expect(textOf(undefined as any)).toBe("");
-  });
-
-  it("returns empty string for null content", () => {
-    expect(textOf(null as any)).toBe("");
-  });
-
-  it("returns string content as-is", () => {
-    expect(textOf("hello")).toBe("hello");
-  });
-
-  it("extracts text parts from array content", () => {
-    const content = [
-      { type: "text" as const, text: "first" },
-      { type: "toolCall" as const, name: "x", id: "1", arguments: {} },
-      { type: "text" as const, text: "second" },
-    ];
-    expect(textOf(content)).toBe("first\nsecond");
-  });
-
-  it("ignores thinking parts", () => {
-    const content = [
-      { type: "thinking" as const, thinking: "let me think" },
-      { type: "text" as const, text: "here is the answer" },
-    ];
-    expect(textOf(content)).toBe("here is the answer");
-  });
-});
-
-describe("thinkingOf", () => {
-  it("returns empty string for undefined content", () => {
-    expect(thinkingOf(undefined as any)).toBe("");
-  });
-
-  it("returns empty string for string content", () => {
-    expect(thinkingOf("hello")).toBe("");
-  });
-
-  it("extracts thinking parts from array content", () => {
-    const content = [
-      { type: "thinking" as const, thinking: "let me think" },
-      { type: "text" as const, text: "here is the answer" },
-    ];
-    expect(thinkingOf(content)).toBe("let me think");
-  });
-
-  it("joins multiple thinking parts", () => {
-    const content = [
-      { type: "thinking" as const, thinking: "first thought" },
-      { type: "text" as const, text: "answer" },
-      { type: "thinking" as const, thinking: "second thought" },
-    ];
-    expect(thinkingOf(content)).toBe("first thought\nsecond thought");
-  });
-});
-
-describe("textOf", () => {
-  it("returns empty string for undefined content", () => {
-    expect(textOf(undefined as any)).toBe("");
-  });
-});