@sting8k/pi-vcc 0.1.2 → 0.1.4

package/README.md

@@ -1,8 +1,10 @@
 # pi-vcc
 
+[![npm](https://img.shields.io/npm/v/@sting8k/pi-vcc)](https://www.npmjs.com/package/@sting8k/pi-vcc)
+
 Algorithmic conversation compactor for [Pi](https://github.com/badlogic/pi-mono). No LLM calls -- produces structured, transcript-preserving summaries using pure extraction and formatting.
 
-Inspired by [VCC](https://github.com/lllyasviel/VCC) (View-oriented Conversation Compiler).
+Inspired by [VCC](https://github.com/lllyasviel/VCC) **(View-oriented Conversation Compiler)**.
 
 ## Why pi-vcc
 
@@ -95,25 +97,25 @@ Pi's default compaction discards old messages permanently. After compaction, the
 
 `vcc_recall` bypasses this by reading the raw session JSONL file directly. It parses every message entry in the file, renders each one into a searchable `RenderedEntry` with a stable index (matching the message's position in the JSONL), role, truncated summary, and associated file paths. This means entry `#41` always refers to the same message regardless of how many compactions have happened.
 
-**Search** uses multi-term matching -- the query is split into terms and all must appear in the entry's role + summary + file paths. This searches across the entire session including compacted regions:
+**Search** matches against the full content of every entry (not just the truncated summary). The query is split into terms and all must appear. Results show a snippet around the first match with surrounding context:
 
 ```
 vcc_recall({ query: "auth token refresh" })   // all terms must match
 ```
 
-**Browse** without a query returns the last 25 entries:
+**Browse** without a query returns the last 25 entries as brief summaries:
 
 ```
 vcc_recall()
 ```
 
-**Expand** switches to full mode -- entries are rendered without truncation, so you get the complete content for specific indices found via search:
+**Expand** returns full untruncated content for specific indices found via search:
 
 ```
 vcc_recall({ expand: [41, 42] })               // full content, no clipping
 ```
 
-Typical workflow: search brief -> find relevant entry indices -> expand those indices for full content.
+Typical workflow: search -> find relevant entry indices from snippets -> expand those indices for full content.
 
 > Some tool results are truncated by Pi core at save time. `expand` returns everything in the JSONL but can't recover what Pi already cut.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sting8k/pi-vcc",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Algorithmic conversation compactor for pi - transcript-preserving structured summaries, no LLM calls",
   "main": "index.ts",
   "keywords": [

package/src/core/content.ts

@@ -10,6 +10,7 @@ export const firstLine = (text: string, max = 200): string =>
   clip(text.split("\n")[0] ?? "", max);
 
 export const textParts = (content: Message["content"]): string[] => {
+  if (!content) return [];
   if (typeof content === "string") return [content];
   return content
     .filter((part) => part.type === "text")
@@ -18,3 +19,14 @@ export const textParts = (content: Message["content"]): string[] => {
 
 export const textOf = (content: Message["content"]): string =>
   textParts(content).join("\n");
+
+/** Extract a snippet of ~`radius` chars around the first match of `term` in `text`. */
+export const snippet = (text: string, term: string, radius = 60): string | null => {
+  const idx = text.toLowerCase().indexOf(term.toLowerCase());
+  if (idx === -1) return null;
+  const start = Math.max(0, idx - radius);
+  const end = Math.min(text.length, idx + term.length + radius);
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < text.length ? "..." : "";
+  return `${prefix}${text.slice(start, end)}${suffix}`;
+};

package/src/core/format-recall.ts

@@ -1,7 +1,7 @@
-import type { RenderedEntry } from "./render-entries";
+import type { SearchHit } from "./search-entries";
 
 export const formatRecallOutput = (
-  entries: RenderedEntry[],
+  entries: SearchHit[],
   query?: string,
 ): string => {
   if (entries.length === 0) {
@@ -16,7 +16,8 @@ export const formatRecallOutput = (
 
   const lines = entries.map((e) => {
     const fileSuffix = e.files?.length ? ` files:[${e.files.join(", ")}]` : "";
-    return `#${e.index} [${e.role}]${fileSuffix} ${e.summary}`;
+    const body = query && e.snippet ? e.snippet : e.summary;
+    return `#${e.index} [${e.role}]${fileSuffix} ${body}`;
   });
 
   return `${header}\n\n${lines.join("\n\n")}`;

package/src/core/normalize.ts

@@ -8,7 +8,7 @@ const normalizeOne = (msg: Message): NormalizedBlock[] => {
     const blocks: NormalizedBlock[] = [];
     const text = sanitize(textOf(msg.content));
     if (text) blocks.push({ kind: "user", text });
-    if (typeof msg.content !== "string") {
+    if (msg.content && typeof msg.content !== "string") {
       for (const part of msg.content) {
         if (part.type === "image") {
           blocks.push({ kind: "user", text: `[image: ${part.mimeType}]` });
@@ -28,6 +28,7 @@ const normalizeOne = (msg: Message): NormalizedBlock[] => {
   }
 
   if (msg.role === "assistant") {
+    if (!msg.content) return [];
     if (typeof msg.content === "string") {
       return [{ kind: "assistant", text: sanitize(msg.content) }];
     }

package/src/core/render-entries.ts

@@ -11,7 +11,7 @@ export interface RenderedEntry {
 }
 
 const toolCalls = (content: Message["content"]): string => {
-  if (typeof content === "string") return "";
+  if (!content || typeof content === "string") return "";
   return content
     .filter((c) => c.type === "toolCall")
     .map((c) => `${c.name}(${summarizeToolArgs(c.arguments)})`)
@@ -19,7 +19,7 @@ const toolCalls = (content: Message["content"]): string => {
 };
 
 const extractFilesFromContent = (content: Message["content"]): string[] => {
-  if (typeof content === "string") return [];
+  if (!content || typeof content === "string") return [];
   return content
     .filter((c) => c.type === "toolCall")
     .map((c) => extractPath(c.arguments))
@@ -38,6 +38,13 @@ export const renderMessage = (msg: Message, index: number, full = false): Render
       summary: `${prefix}[${msg.toolName}] ${text}`,
     };
   }
+  // bashExecution has command+output instead of content
+  if ((msg as any).role === "bashExecution") {
+    const cmd = (msg as any).command ?? "";
+    const out = (msg as any).output ?? "";
+    const text = full ? `$ ${cmd}\n${out}` : clip(`$ ${cmd}\n${out}`, 300);
+    return { index, role: "bash", summary: text };
+  }
   const text = full ? textOf(msg.content) : clip(textOf(msg.content), 300);
   const tools = toolCalls(msg.content);
   const files = extractFilesFromContent(msg.content);

package/src/core/search-entries.ts

@@ -1,14 +1,45 @@
+import type { Message } from "@mariozechner/pi-ai";
 import type { RenderedEntry } from "./render-entries";
+import { textOf, snippet } from "./content";
+
+export interface SearchHit extends RenderedEntry {
+  /** Context snippet around the first matched term (only when query provided) */
+  snippet?: string;
+}
+
+/** Build full searchable text for a message. */
+const fullText = (msg: Message): string => {
+  if ((msg as any).role === "bashExecution") {
+    return `${(msg as any).command ?? ""} ${(msg as any).output ?? ""}`;
+  }
+  return textOf(msg.content);
+};
 
 export const searchEntries = (
   entries: RenderedEntry[],
+  messages: Message[],
   query?: string,
-): RenderedEntry[] => {
+): SearchHit[] => {
   if (!query?.trim()) return entries;
   const terms = query.toLowerCase().split(/\s+/);
-  return entries.filter((e) => {
+
+  const hits: SearchHit[] = [];
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    const msg = messages[i];
+    const text = msg ? fullText(msg) : e.summary;
     const filePart = e.files?.join(" ") ?? "";
-    const hay = `${e.role} ${e.summary} ${filePart}`.toLowerCase();
-    return terms.every((t) => hay.includes(t));
-  });
+    const hay = `${e.role} ${text} ${filePart}`.toLowerCase();
+
+    if (terms.every((t) => hay.includes(t))) {
+      // Find snippet around the first matching term in the raw text
+      let snip: string | undefined;
+      for (const t of terms) {
+        const s = snippet(text, t);
+        if (s) { snip = s; break; }
+      }
+      hits.push({ ...e, snippet: snip });
+    }
+  }
+  return hits;
 };

package/src/tools/recall.ts

@@ -17,9 +17,10 @@ const loadAllMessages = (sessionFile: string, full: boolean) => {
       entries.push(JSON.parse(line));
     } catch {}
   }
-  return entries
-    .filter((e) => e.type === "message" && e.message)
-    .map((e, i) => renderMessage(e.message, i, full));
+  const messageEntries = entries.filter((e) => e.type === "message" && e.message);
+  const rendered = messageEntries.map((e, i) => renderMessage(e.message, i, full));
+  const rawMessages = messageEntries.map((e) => e.message);
+  return { rendered, rawMessages };
 };
 
 export const registerRecallTool = (pi: ExtensionAPI) => {
@@ -54,7 +55,7 @@ export const registerRecallTool = (pi: ExtensionAPI) => {
       const hasExpand = expandSet.size > 0;
 
       if (hasExpand && !params.query) {
-        const fullMsgs = loadAllMessages(sessionFile, true);
+        const { rendered: fullMsgs } = loadAllMessages(sessionFile, true);
         const expanded = fullMsgs.filter((m) => expandSet.has(m.index));
         if (expanded.length === 0) {
           return {
@@ -69,9 +70,9 @@ export const registerRecallTool = (pi: ExtensionAPI) => {
         };
       }
 
-      const msgs = loadAllMessages(sessionFile, false);
+      const { rendered: msgs, rawMessages } = loadAllMessages(sessionFile, false);
       const results = params.query?.trim()
-        ? searchEntries(msgs, params.query).slice(0, MAX_RESULTS)
+        ? searchEntries(msgs, rawMessages, params.query).slice(0, MAX_RESULTS)
         : msgs.slice(-DEFAULT_RECENT);
       const output = formatRecallOutput(results, params.query);
 

package/tests/content.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "bun:test";
+import { textParts, textOf, clip, firstLine } from "../src/core/content";
+
+describe("textParts", () => {
+  it("returns [] for undefined content", () => {
+    expect(textParts(undefined as any)).toEqual([]);
+  });
+
+  it("returns [] for null content", () => {
+    expect(textParts(null as any)).toEqual([]);
+  });
+
+  it("wraps string content", () => {
+    expect(textParts("hello")).toEqual(["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(textParts(content)).toEqual(["first", "second"]);
+  });
+});
+
+describe("textOf", () => {
+  it("returns empty string for undefined content", () => {
+    expect(textOf(undefined as any)).toBe("");
+  });
+});

package/tests/render-entries.test.ts

@@ -36,5 +36,27 @@ describe("renderMessage", () => {
     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/search-entries.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from "bun:test";
 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" },
@@ -9,25 +10,53 @@ const entries: RenderedEntry[] = [
   { index: 3, role: "assistant", summary: "Found the root cause" },
 ];
 
+// Matching raw messages for full-text search
+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" }] } as any,
+];
+
 describe("searchEntries", () => {
   it("returns all for empty query", () => {
-    expect(searchEntries(entries)).toEqual(entries);
-    expect(searchEntries(entries, "")).toEqual(entries);
+    expect(searchEntries(entries, messages)).toEqual(entries);
+    expect(searchEntries(entries, messages, "")).toEqual(entries);
   });
 
   it("filters by single term", () => {
-    const r = searchEntries(entries, "login");
+    const r = searchEntries(entries, messages, "login");
     expect(r).toHaveLength(1);
     expect(r[0].index).toBe(0);
   });
 
   it("filters by multiple terms (AND)", () => {
-    const r = searchEntries(entries, "root cause");
+    const r = searchEntries(entries, messages, "root cause");
     expect(r).toHaveLength(1);
     expect(r[0].index).toBe(3);
   });
 
   it("returns empty for no match", () => {
-    expect(searchEntries(entries, "xyz123")).toEqual([]);
+    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");
   });
 });