pi-vcc 0.4.0

package/tests/search-entries.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect } from "vitest";
+import { searchEntries } from "../src/core/search-entries";
+import type { RenderedEntry } from "../src/core/render-entries";
+import type { Message } from "@mariozechner/pi-ai";
+
+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 in auth module" },
+];
+
+const messages: Message[] = [
+  { role: "user", content: "Fix login bug" } as any,
+  { role: "assistant", content: [{ type: "text", text: "Reading auth.ts" }] } as any,
+  { role: "toolResult", content: [{ type: "text", text: "[Read] code here" }] } as any,
+  { role: "assistant", content: [{ type: "text", text: "Found the root cause in auth module" }] } as any,
+];
+
+describe("searchEntries", () => {
+  it("returns all for empty query", () => {
+    expect(searchEntries(entries, messages)).toEqual(entries);
+    expect(searchEntries(entries, messages, "")).toEqual(entries);
+  });
+
+  it("filters by single term", () => {
+    const r = searchEntries(entries, messages, "login");
+    expect(r).toHaveLength(1);
+    expect(r[0].index).toBe(0);
+  });
+
+  it("returns empty for no match", () => {
+    expect(searchEntries(entries, messages, "xyz123")).toEqual([]);
+  });
+
+  it("finds keyword beyond clip boundary in full content", () => {
+    const longText = "A".repeat(400) + " hidden_keyword here";
+    const longEntries: RenderedEntry[] = [
+      { index: 0, role: "user", summary: "A".repeat(300) },
+    ];
+    const longMsgs: Message[] = [
+      { role: "user", content: longText } as any,
+    ];
+    const r = searchEntries(longEntries, longMsgs, "hidden_keyword");
+    expect(r).toHaveLength(1);
+    expect(r[0].snippet).toContain("hidden_keyword");
+  });
+
+  it("returns snippet around matched term", () => {
+    const r = searchEntries(entries, messages, "root");
+    expect(r).toHaveLength(1);
+    expect(r[0].snippet).toBeDefined();
+    expect(r[0].snippet).toContain("root");
+  });
+
+  // ── regex support ──
+
+  it("supports regex pattern: alternation", () => {
+    const r = searchEntries(entries, messages, "login|auth");
+    expect(r).toHaveLength(3); // "login bug", "auth.ts", "auth module"
+    expect(r.map((h) => h.index).sort()).toEqual([0, 1, 3]);
+  });
+
+  it("supports regex pattern: wildcard", () => {
+    const r = searchEntries(entries, messages, "Read.*auth");
+    expect(r).toHaveLength(1);
+    expect(r[0].index).toBe(1);
+  });
+
+  it("falls back to escaped literal for invalid regex", () => {
+    const extraEntries: RenderedEntry[] = [
+      { index: 0, role: "user", summary: "test (foo" },
+      { index: 1, role: "assistant", summary: "no match here" },
+    ];
+    const extraMsgs: Message[] = [
+      { role: "user", content: "error with (foo pattern" } as any,
+      { role: "assistant", content: [{ type: "text", text: "no match here" }] } as any,
+    ];
+    const r = searchEntries(extraEntries, extraMsgs, "(foo");
+    expect(r).toHaveLength(1);
+    expect(r[0].index).toBe(0);
+  });
+
+  it("regex is case-insensitive", () => {
+    const r = searchEntries(entries, messages, "FIX|ROOT");
+    expect(r).toHaveLength(2);
+  });
+
+  // ── natural language queries (OR logic + ranking) ──
+
+  it("natural language query uses OR logic", () => {
+    // "root cause auth" -- matches entries containing ANY of these terms
+    const r = searchEntries(entries, messages, "root cause auth");
+    expect(r.length).toBeGreaterThanOrEqual(2); // #3 has all 3, #1 has auth
+    // Best match (highest BM25) should come first
+    expect(r[0].index).toBe(3); // "Found the root cause in auth module" matches all 3
+  });
+
+  it("natural language ranks by BM25 score", () => {
+    const r = searchEntries(entries, messages, "root cause auth");
+    // Top result has more terms matched = higher BM25 score
+    expect(r[0].matchCount!).toBeGreaterThanOrEqual(r[r.length - 1].matchCount!);
+  });
+
+  it("filters stopwords from queries", () => {
+    // "the root cause of it" → stopwords: the, of, it → meaningful: root, cause
+    const r = searchEntries(entries, messages, "the root cause of it");
+    expect(r).toHaveLength(1);
+    expect(r[0].index).toBe(3);
+  });
+
+  it("keeps all terms if all are stopwords", () => {
+    // When all terms are stopwords, keep them (don't drop everything)
+    // "the" appears in "Found the root cause" so it matches
+    const r = searchEntries(entries, messages, "the");
+    expect(r.length).toBeGreaterThan(0);
+  });
+
+  // ── line-based snippet ──
+
+  it("snippet shows context lines around match", () => {
+    const multiline = "line 0\nline 1\nline 2 TARGET\nline 3\nline 4\nline 5";
+    const e: RenderedEntry[] = [{ index: 0, role: "user", summary: "test" }];
+    const m: Message[] = [{ role: "user", content: multiline } as any];
+    const r = searchEntries(e, m, "TARGET");
+    expect(r).toHaveLength(1);
+    const snip = r[0].snippet!;
+    expect(snip).toContain("line 2 TARGET");
+    expect(snip).toContain("line 0");
+    expect(snip).toContain("line 4");
+    expect(snip).not.toContain("line 5");
+  });
+
+  it("snippet handles match at beginning", () => {
+    const multiline = "TARGET here\nline 1\nline 2\nline 3";
+    const e: RenderedEntry[] = [{ index: 0, role: "user", summary: "test" }];
+    const m: Message[] = [{ role: "user", content: multiline } as any];
+    const r = searchEntries(e, m, "TARGET");
+    const snip = r[0].snippet!;
+    expect(snip).toContain("TARGET here");
+    expect(snip).toContain("line 2");
+    expect(snip).not.toContain("line 3");
+  });
+});

package/tests/settings-scaffold.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock fs/promises before importing settings
+const mockReadFile = vi.fn();
+const mockWriteFile = vi.fn();
+const mockMkdir = vi.fn();
+
+vi.mock("fs/promises", () => ({
+  readFile: mockReadFile,
+  writeFile: mockWriteFile,
+  mkdir: mockMkdir,
+}));
+
+// We need to mock dirname to control the directory path
+// but it's used internally. Instead, mock the env var to control settingsPath().
+const ORIGINAL_ENV = process.env.PI_VCC_CONFIG_PATH;
+
+describe("scaffoldSettingsAsync", () => {
+  let scaffoldSettingsAsync: () => Promise<void>;
+  let DEFAULT_SETTINGS: Record<string, unknown>;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Set a known config path
+    process.env.PI_VCC_CONFIG_PATH = "/tmp/test-vcc/pi-vcc-config.json";
+    // Re-import to pick up env var
+    vi.resetModules();
+    const mod = await import("../src/core/settings");
+    scaffoldSettingsAsync = mod.scaffoldSettingsAsync;
+    DEFAULT_SETTINGS = mod.DEFAULT_SETTINGS as Record<string, unknown>;
+  });
+
+  it("creates config file with defaults when no file exists", async () => {
+    // readFile throws ENOENT → file doesn't exist
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    mockReadFile.mockRejectedValue(enoent);
+    mockMkdir.mockResolvedValue(undefined);
+    mockWriteFile.mockResolvedValue(undefined);
+
+    await scaffoldSettingsAsync();
+
+    // Should mkdir for parent dir
+    expect(mockMkdir).toHaveBeenCalledWith("/tmp/test-vcc", { recursive: true });
+    // Should write default settings
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      "/tmp/test-vcc/pi-vcc-config.json",
+      `${JSON.stringify(DEFAULT_SETTINGS, null, 2)}\n`,
+    );
+    // Should be called exactly once (create, no second write)
+    expect(mockWriteFile).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT clobber existing valid config (only fills missing keys)", async () => {
+    const existing = { overrideDefaultCompaction: true, debug: false, extraction: { references: { enabled: true, extraUrlPatterns: [], extraGithubRefPatterns: [], extraVersionPatterns: [], extraBranchPatterns: [] }, keySignals: { enabled: true, extraConstraintPatterns: [], extraDecisionPatterns: [], extraStatusPatterns: [] }, goals: { enabled: true, extraTaskVerbs: [], extraScopeChangeWords: [] } } };
+    mockReadFile.mockResolvedValue(JSON.stringify(existing));
+    mockWriteFile.mockResolvedValue(undefined);
+
+    await scaffoldSettingsAsync();
+
+    // All DEFAULT_SETTINGS keys already present → no write
+    expect(mockWriteFile).not.toHaveBeenCalled();
+  });
+
+  it("fills in missing default keys and writes", async () => {
+    // Partial config missing 'debug' key
+    const partial = { overrideDefaultCompaction: false, extraction: { references: { enabled: true, extraUrlPatterns: [], extraGithubRefPatterns: [], extraVersionPatterns: [], extraBranchPatterns: [] }, keySignals: { enabled: true, extraConstraintPatterns: [], extraDecisionPatterns: [], extraStatusPatterns: [] }, goals: { enabled: true, extraTaskVerbs: [], extraScopeChangeWords: [] } } };
+    mockReadFile.mockResolvedValue(JSON.stringify(partial));
+    mockWriteFile.mockResolvedValue(undefined);
+
+    await scaffoldSettingsAsync();
+
+    expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    const written = mockWriteFile.mock.calls[0][1] as string;
+    const parsed = JSON.parse(written);
+    expect(parsed.debug).toBe(false);
+    // Existing key preserved
+    expect(parsed.overrideDefaultCompaction).toBe(false);
+  });
+
+  it("no-ops when existing file has invalid JSON", async () => {
+    mockReadFile.mockResolvedValue("this is not json {{{");
+
+    await scaffoldSettingsAsync();
+
+    expect(mockWriteFile).not.toHaveBeenCalled();
+    expect(mockMkdir).not.toHaveBeenCalled();
+  });
+
+  it("creates parent directory if missing", async () => {
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    mockReadFile.mockRejectedValue(enoent);
+    mockMkdir.mockResolvedValue(undefined);
+    mockWriteFile.mockResolvedValue(undefined);
+
+    await scaffoldSettingsAsync();
+
+    expect(mockMkdir).toHaveBeenCalledWith("/tmp/test-vcc", { recursive: true });
+  });
+
+  it("no-ops on any error (best-effort, catches exceptions)", async () => {
+    mockReadFile.mockRejectedValue(new Error("permission denied"));
+
+    // Should not throw
+    await expect(scaffoldSettingsAsync()).resolves.toBeUndefined();
+    expect(mockWriteFile).not.toHaveBeenCalled();
+  });
+
+  it("returns void/undefined (fire-and-forget style)", async () => {
+    const enoent = new Error("ENOENT") as NodeJS.ErrnoException;
+    enoent.code = "ENOENT";
+    mockReadFile.mockRejectedValue(enoent);
+    mockMkdir.mockResolvedValue(undefined);
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await scaffoldSettingsAsync();
+    expect(result).toBeUndefined();
+  });
+});

package/tests/settings.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { DEFAULT_SETTINGS, loadSettings } from "../src/core/settings";
+
+describe("settings", () => {
+  it("DEFAULT_SETTINGS has extraction config with all categories", () => {
+    expect(DEFAULT_SETTINGS.extraction).toBeDefined();
+    expect(DEFAULT_SETTINGS.extraction.references.enabled).toBe(true);
+    expect(DEFAULT_SETTINGS.extraction.keySignals.enabled).toBe(true);
+    expect(DEFAULT_SETTINGS.extraction.goals.enabled).toBe(true);
+  });
+
+  it("DEFAULT_SETTINGS extraction arrays are empty (additive only)", () => {
+    expect(DEFAULT_SETTINGS.extraction.references.extraUrlPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.references.extraGithubRefPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.references.extraVersionPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.references.extraBranchPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.keySignals.extraConstraintPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.keySignals.extraDecisionPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.keySignals.extraStatusPatterns).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.goals.extraTaskVerbs).toEqual([]);
+    expect(DEFAULT_SETTINGS.extraction.goals.extraScopeChangeWords).toEqual([]);
+  });
+
+  it("loadSettings returns valid config with extraction defaults", async () => {
+    const s = await loadSettings();
+    // Don't assert on boolean fields that may differ per environment
+    expect(s.extraction).toBeDefined();
+    expect(s.extraction.references.enabled).toBe(true);
+    expect(s.extraction.keySignals.enabled).toBe(true);
+    expect(s.extraction.goals.enabled).toBe(true);
+  });
+});

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 };
+};

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.ts"],
+  },
+});