@sting8k/pi-vcc 0.1.0

package/src/core/render-entries.ts

@@ -0,0 +1,48 @@
+import type { Message } from "@mariozechner/pi-ai";
+import { clip, textOf } from "./content";
+import { summarizeToolArgs } from "./tool-args";
+import { extractPath } from "./tool-args";
+
+export interface RenderedEntry {
+  index: number;
+  role: string;
+  summary: string;
+  files?: string[];
+}
+
+const toolCalls = (content: Message["content"]): string => {
+  if (typeof content === "string") return "";
+  return content
+    .filter((c) => c.type === "toolCall")
+    .map((c) => `${c.name}(${summarizeToolArgs(c.arguments)})`)
+    .join(", ");
+};
+
+const extractFilesFromContent = (content: Message["content"]): string[] => {
+  if (typeof content === "string") return [];
+  return content
+    .filter((c) => c.type === "toolCall")
+    .map((c) => extractPath(c.arguments))
+    .filter((p): p is string => p !== null);
+};
+
+export const renderMessage = (msg: Message, index: number, full = false): RenderedEntry => {
+  if (msg.role === "user") {
+    return { index, role: "user", summary: full ? textOf(msg.content) : clip(textOf(msg.content), 300) };
+  }
+  if (msg.role === "toolResult") {
+    const prefix = msg.isError ? "ERROR " : "";
+    const text = full ? textOf(msg.content) : clip(textOf(msg.content), 200);
+    return {
+      index, role: "tool_result",
+      summary: `${prefix}[${msg.toolName}] ${text}`,
+    };
+  }
+  const text = full ? textOf(msg.content) : clip(textOf(msg.content), 300);
+  const tools = toolCalls(msg.content);
+  const files = extractFilesFromContent(msg.content);
+  const summary = tools ? `${tools}\n${text}` : text;
+  return { index, role: "assistant", summary, ...(files.length > 0 && { files }) };
+};
+
+

package/src/core/report.ts

@@ -0,0 +1,225 @@
+import type { Message } from "@mariozechner/pi-ai";
+import { buildSections } from "./build-sections";
+import { clip } from "./content";
+import { normalize } from "./normalize";
+import { renderMessage } from "./render-entries";
+import { searchEntries } from "./search-entries";
+import { type CompileInput, compile } from "./summarize";
+
+const headers = [
+  "Session Goal", "Current State", "What Was Done",
+  "Important Findings", "Files And Changes", "Open Problems",
+  "Decisions And Constraints", "User Preferences", "Next Best Steps",
+];
+
+interface RoleCounts {
+  user: number;
+  assistant: number;
+  toolResult: number;
+}
+
+interface BlockCounts {
+  user: number;
+  assistant: number;
+  toolCalls: number;
+  toolResults: number;
+  thinking: number;
+}
+
+export interface RecallProbe {
+  label: string;
+  sourceText: string;
+  query: string;
+  summaryMentioned: boolean;
+  recallHits: number;
+}
+
+export interface CompactReport {
+  summary: string;
+  before: {
+    messageCount: number;
+    roleCounts: RoleCounts;
+    blockCounts: BlockCounts;
+    inputChars: number;
+    estimatedTokens: number;
+    topFiles: string[];
+    preview: string;
+  };
+  after: {
+    summaryLength: number;
+    estimatedTokens: number;
+    sectionCount: number;
+    summaryPreview: string;
+    goalsCount: number;
+    findingsCount: number;
+    filesCount: number;
+    blockersCount: number;
+    decisionsCount: number;
+    preferencesCount: number;
+    nextStepsCount: number;
+  };
+  compression: {
+    charsBefore: number;
+    charsAfter: number;
+    ratio: number;
+    messagesBefore: number;
+  };
+  recall: {
+    probes: RecallProbe[];
+  };
+}
+
+const estimateTokensFromChars = (chars: number): number =>
+  Math.ceil(chars / 4);
+
+const countRoles = (messages: Message[]): RoleCounts => {
+  const counts: RoleCounts = { user: 0, assistant: 0, toolResult: 0 };
+  for (const msg of messages) {
+    if (msg.role === "user") counts.user += 1;
+    else if (msg.role === "assistant") counts.assistant += 1;
+    else if (msg.role === "toolResult") counts.toolResult += 1;
+  }
+  return counts;
+};
+
+const countBlocks = (messages: Message[]): BlockCounts => {
+  const counts: BlockCounts = {
+    user: 0,
+    assistant: 0,
+    toolCalls: 0,
+    toolResults: 0,
+    thinking: 0,
+  };
+
+  for (const block of normalize(messages)) {
+    if (block.kind === "user") counts.user += 1;
+    else if (block.kind === "assistant") counts.assistant += 1;
+    else if (block.kind === "tool_call") counts.toolCalls += 1;
+    else if (block.kind === "tool_result") counts.toolResults += 1;
+    else if (block.kind === "thinking") counts.thinking += 1;
+  }
+
+  return counts;
+};
+
+const inputCharsOf = (messages: Message[]): number =>
+  messages
+    .map((msg, index) => renderMessage(msg, index).summary.length)
+    .reduce((sum, len) => sum + len, 0);
+
+const topFilesOf = (messages: Message[], fileOps?: CompileInput["fileOps"]): string[] => {
+  const data = buildSections({ blocks: normalize(messages), fileOps });
+  return [
+    ...data.filesModified,
+    ...data.filesCreated,
+    ...data.filesRead,
+  ].filter((file, index, all) => all.indexOf(file) === index).slice(0, 10);
+};
+
+const previewOf = (messages: Message[], edgeCount = 3): string => {
+  const rendered = messages.map((msg, index) => renderMessage(msg, index));
+  if (rendered.length === 0) return "(empty)";
+  if (rendered.length <= edgeCount * 2) {
+    return rendered
+      .map((entry) => `#${entry.index} [${entry.role}] ${clip(entry.summary, 220)}`)
+      .join("\n");
+  }
+
+  const first = rendered.slice(0, edgeCount);
+  const last = rendered.slice(-edgeCount);
+  return [
+    ...first.map((entry) => `#${entry.index} [${entry.role}] ${clip(entry.summary, 220)}`),
+    "...",
+    ...last.map((entry) => `#${entry.index} [${entry.role}] ${clip(entry.summary, 220)}`),
+  ].join("\n");
+};
+
+const sectionCountOf = (summary: string): number =>
+  headers.filter((header) => summary.includes(`[${header}]`)).length;
+
+const queryTermsOf = (text: string): string[] =>
+  (text.match(/[\p{L}\p{N}_./-]{3,}/gu) ?? [])
+    .map((part) => part.trim())
+    .filter(Boolean);
+
+const queryOf = (text: string): string => {
+  const terms = queryTermsOf(text);
+  return terms.slice(0, 6).join(" ");
+};
+
+const matchesQuery = (text: string, query: string): boolean => {
+  const hay = text.toLowerCase();
+  return query
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean)
+    .every((term) => hay.includes(term));
+};
+
+const probesOf = (messages: Message[], summary: string, fileOps?: CompileInput["fileOps"]): RecallProbe[] => {
+  const data = buildSections({ blocks: normalize(messages), fileOps });
+  const rawProbes = [
+    { label: "goal", text: data.sessionGoal[0] ?? "" },
+    { label: "file", text: [...data.filesModified, ...data.filesCreated, ...data.filesRead][0] ?? "" },
+    { label: "problem", text: data.openProblems[0] ?? data.importantFindings[0] ?? "" },
+  ];
+
+  const rendered = messages.map((msg, index) => renderMessage(msg, index));
+
+  return rawProbes
+    .map(({ label, text }) => {
+      const sourceText = text.trim();
+      const query = queryOf(sourceText);
+      if (!query) return null;
+      return {
+        label,
+        sourceText,
+        query,
+        summaryMentioned: matchesQuery(summary, query),
+        recallHits: searchEntries(rendered, query).length,
+      };
+    })
+    .filter((probe): probe is RecallProbe => probe !== null);
+};
+
+export const buildCompactReport = (input: CompileInput): CompactReport => {
+  const summary = compile(input);
+  const data = buildSections({ blocks: normalize(input.messages), fileOps: input.fileOps });
+  const inputChars = inputCharsOf(input.messages);
+  const topFiles = topFilesOf(input.messages, input.fileOps);
+
+  return {
+    summary,
+    before: {
+      messageCount: input.messages.length,
+      roleCounts: countRoles(input.messages),
+      blockCounts: countBlocks(input.messages),
+      inputChars,
+      estimatedTokens: estimateTokensFromChars(inputChars),
+      topFiles,
+      preview: previewOf(input.messages),
+    },
+    after: {
+      summaryLength: summary.length,
+      estimatedTokens: estimateTokensFromChars(summary.length),
+      sectionCount: sectionCountOf(summary),
+      summaryPreview: summary,
+      goalsCount: data.sessionGoal.length,
+      findingsCount: data.importantFindings.length,
+      filesCount: data.filesRead.length + data.filesModified.length + data.filesCreated.length,
+      blockersCount: data.openProblems.length,
+      decisionsCount: data.decisions.length,
+      preferencesCount: data.userPreferences.length,
+      nextStepsCount: data.nextSteps.length,
+    },
+    compression: {
+      charsBefore: inputChars,
+      charsAfter: summary.length,
+      ratio: summary.length === 0 ? 0 : Number((inputChars / summary.length).toFixed(2)),
+      messagesBefore: input.messages.length,
+    },
+    recall: {
+      probes: probesOf(input.messages, summary, input.fileOps),
+    },
+  };
+};

package/src/core/sanitize.ts

@@ -0,0 +1,5 @@
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+const CTRL_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
+
+export const sanitize = (text: string): string =>
+  text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(ANSI_RE, "").replace(CTRL_RE, "");

package/src/core/search-entries.ts

@@ -0,0 +1,14 @@
+import type { RenderedEntry } from "./render-entries";
+
+export const searchEntries = (
+  entries: RenderedEntry[],
+  query?: string,
+): RenderedEntry[] => {
+  if (!query?.trim()) return entries;
+  const terms = query.toLowerCase().split(/\s+/);
+  return entries.filter((e) => {
+    const filePart = e.files?.join(" ") ?? "";
+    const hay = `${e.role} ${e.summary} ${filePart}`.toLowerCase();
+    return terms.every((t) => hay.includes(t));
+  });
+};

package/src/core/summarize.ts

@@ -0,0 +1,81 @@
+import type { Message } from "@mariozechner/pi-ai";
+import type { FileOps } from "../types";
+import { normalize } from "./normalize";
+import { filterNoise } from "./filter-noise";
+import { buildSections } from "./build-sections";
+import { formatSummary } from "./format";
+import { redact } from "./redact";
+
+export interface CompileInput {
+  messages: Message[];
+  previousSummary?: string;
+  fileOps?: FileOps;
+}
+
+const headers = [
+  "Session Goal", "Key Conversation Turns", "Actions Taken",
+  "Important Evidence", "Files And Changes", "Outstanding Context",
+  "User Preferences",
+];
+
+const sectionOf = (text: string, header: string): string => {
+  const start = text.indexOf(`[${header}]`);
+  if (start < 0) return "";
+  const after = text.slice(start);
+  const next = headers.map((h) => h === header ? -1 : after.indexOf(`[${h}]`))
+    .filter((n) => n > 0).sort((a, b) => a - b)[0];
+  return (next ? after.slice(0, next) : after).trim();
+};
+
+const VOLATILE_SECTIONS = new Set([
+  "Outstanding Context",
+]);
+
+const APPENDABLE_SECTIONS = new Set([
+  "Key Conversation Turns", "Actions Taken", "Important Evidence",
+  "Files And Changes", "User Preferences",
+]);
+
+const extractBullets = (section: string): string[] =>
+  section.split("\n").filter((l) => /^\s*[-*]/.test(l) || /^\s*(Read|Modified|Created):/.test(l));
+
+const mergeSectionContent = (header: string, prev: string, fresh: string): string => {
+  if (!prev) return fresh;
+  if (!fresh) {
+    if (VOLATILE_SECTIONS.has(header)) return "";
+    return prev;
+  }
+  if (VOLATILE_SECTIONS.has(header)) return fresh;
+  if (APPENDABLE_SECTIONS.has(header)) {
+    const oldBullets = extractBullets(prev);
+    const newBullets = extractBullets(fresh);
+    const combined = [...new Set([...oldBullets, ...newBullets])];
+    const headerLine = `[${header}]`;
+    return headerLine + "\n" + combined.join("\n");
+  }
+  return fresh;
+};
+
+const mergePrevious = (prev: string, fresh: string): string => {
+  const merged = headers
+    .map((header) => {
+      const freshSec = sectionOf(fresh, header);
+      const prevSec = sectionOf(prev, header);
+      return mergeSectionContent(header, prevSec, freshSec);
+    })
+    .filter(Boolean);
+  return merged.join("\n\n");
+};
+
+const SUMMARY_MAX_CHARS = 12_000;
+
+export const compile = (input: CompileInput): string => {
+  const blocks = filterNoise(normalize(input.messages));
+  const data = buildSections({ blocks, fileOps: input.fileOps });
+  const fresh = formatSummary(data);
+  const merged = input.previousSummary ? mergePrevious(input.previousSummary, fresh) : fresh;
+  const redacted = redact(merged);
+  return redacted.length > SUMMARY_MAX_CHARS
+    ? redacted.slice(0, SUMMARY_MAX_CHARS) + "\n...(summary truncated)"
+    : redacted;
+};

package/src/core/tool-args.ts

@@ -0,0 +1,14 @@
+export const extractPath = (args: Record<string, unknown>): string | null => {
+  for (const key of ["path", "file_path", "filePath", "file"]) {
+    if (typeof args[key] === "string") return args[key] as string;
+  }
+  return null;
+};
+
+export const summarizeToolArgs = (args: Record<string, unknown>): string => {
+  const path = extractPath(args);
+  if (path) return `path=${path}`;
+  if (typeof args.command === "string") return `command=${args.command}`;
+  if (typeof args.query === "string") return `query=${args.query}`;
+  return Object.keys(args).join(", ");
+};

package/src/details.ts

@@ -0,0 +1,7 @@
+export interface PiVccCompactionDetails {
+  compactor: "pi-vcc";
+  version: number;
+  sections: string[];
+  sourceMessageCount: number;
+  previousSummaryUsed: boolean;
+}

package/src/extract/decisions.ts

@@ -0,0 +1,32 @@
+import type { NormalizedBlock } from "../types";
+import { clip, nonEmptyLines } from "../core/content";
+
+const DECISION_PATTERNS = [
+  /\bdecid(ed|ing)\b/i,
+  /\bchose\b/i,
+  /\bwill use\b/i,
+  /\bgoing with\b/i,
+  /\bapproach[:\s]/i,
+  /\bconstraint[:\s]/i,
+  /\brequirement[:\s]/i,
+  /\bmust\b/i,
+  /\bshould not\b/i,
+  /\barchitecture/i,
+];
+
+export const extractDecisions = (blocks: NormalizedBlock[]): string[] => {
+  const decisions: string[] = [];
+
+  for (const b of blocks) {
+    if (b.kind !== "assistant" && b.kind !== "user") continue;
+    for (const line of nonEmptyLines(b.text)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.length < 10) continue;
+      if (DECISION_PATTERNS.some((p) => p.test(trimmed))) {
+        decisions.push(clip(trimmed, 200));
+      }
+    }
+  }
+
+  return [...new Set(decisions)].slice(0, 10);
+};

package/src/extract/files.ts

@@ -0,0 +1,46 @@
+import type { FileOps, NormalizedBlock } from "../types";
+import { extractPath } from "../core/tool-args";
+
+interface FileActivity {
+  read: Set<string>;
+  modified: Set<string>;
+  created: Set<string>;
+}
+
+const FILE_READ_TOOLS = new Set([
+  "Read", "read_file", "tilth", "View",
+]);
+
+const FILE_WRITE_TOOLS = new Set([
+  "Edit", "Write", "edit", "write", "edit_file", "write_file",
+  "MultiEdit",
+]);
+
+const FILE_CREATE_TOOLS = new Set([
+  "Write", "write", "write_file",
+]);
+
+export const extractFiles = (
+  blocks: NormalizedBlock[],
+  fileOps?: FileOps,
+): FileActivity => {
+  const act: FileActivity = {
+    read: new Set(fileOps?.readFiles ?? []),
+    modified: new Set(fileOps?.modifiedFiles ?? []),
+    created: new Set(fileOps?.createdFiles ?? []),
+  };
+
+  for (const b of blocks) {
+    if (b.kind !== "tool_call") continue;
+    const p = extractPath(b.args);
+    if (!p) continue;
+
+    if (FILE_READ_TOOLS.has(b.name)) act.read.add(p);
+    if (FILE_WRITE_TOOLS.has(b.name)) act.modified.add(p);
+    if (FILE_CREATE_TOOLS.has(b.name)) act.created.add(p);
+  }
+
+  return act;
+};
+
+

package/src/extract/findings.ts

@@ -0,0 +1,27 @@
+import type { NormalizedBlock } from "../types";
+import { clip } from "../core/content";
+
+const TRUNCATE_TOKENS = 128;
+const NOISE_TOOLS = new Set(["TodoWrite", "ToolSearch", "Skill"]);
+
+const truncateText = (text: string, limit = TRUNCATE_TOKENS): string => {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length <= limit) return text;
+  return words.slice(0, limit).join(" ") + "...(truncated)";
+};
+
+export const extractFindings = (blocks: NormalizedBlock[]): string[] => {
+  const results: string[] = [];
+
+  for (const b of blocks) {
+    if (b.kind !== "tool_result") continue;
+    if (b.isError) continue;
+    if (NOISE_TOOLS.has(b.name)) continue;
+    const text = b.text.trim();
+    if (!text || text.length < 20) continue;
+    results.push(`[${b.name}] ${truncateText(text, TRUNCATE_TOKENS)}`);
+  }
+
+  return results.slice(-15);
+};
+

package/src/extract/goals.ts

@@ -0,0 +1,41 @@
+import type { NormalizedBlock } from "../types";
+import { nonEmptyLines, clip } from "../core/content";
+
+const SCOPE_CHANGE_RE =
+  /\b(instead|actually|change of plan|forget that|new task|switch to|now I want|pivot|let'?s do|stop .* and)\b/i;
+
+const TASK_RE =
+  /\b(fix|implement|add|create|build|refactor|debug|investigate|update|remove|delete|migrate|deploy|test|write|set up)\b/i;
+
+const NOISE_SHORT_RE = /^(ok|yes|no|sure|yeah|yep|go|hi|hey|thx|thanks|ok\b.*|y|n|k)\s*[.!?]*$/i;
+
+const isSubstantiveGoal = (text: string): boolean =>
+  text.length > 5 && !NOISE_SHORT_RE.test(text.trim());
+
+export const extractGoals = (blocks: NormalizedBlock[]): string[] => {
+  const goals: string[] = [];
+  let latestScopeChange: string[] | null = null;
+
+  for (const b of blocks) {
+    if (b.kind !== "user") continue;
+    const lines = nonEmptyLines(b.text).filter(isSubstantiveGoal);
+    if (lines.length === 0) continue;
+
+    if (goals.length === 0) {
+      goals.push(...lines.slice(0, 3));
+      continue;
+    }
+
+    if (SCOPE_CHANGE_RE.test(b.text)) {
+      latestScopeChange = lines.slice(0, 3).map((l) => clip(l, 200));
+    } else if (TASK_RE.test(b.text) && lines[0].length > 15) {
+      latestScopeChange = lines.slice(0, 2).map((l) => clip(l, 200));
+    }
+  }
+
+  if (latestScopeChange) {
+    goals.push("[Scope change]", ...latestScopeChange);
+  }
+
+  return goals.slice(0, 8);
+};

package/src/extract/preferences.ts

@@ -0,0 +1,30 @@
+import type { NormalizedBlock } from "../types";
+import { clip, nonEmptyLines } from "../core/content";
+
+const PREF_PATTERNS = [
+  /\bprefer\b/i,
+  /\bdon'?t want\b/i,
+  /\balways\b/i,
+  /\bnever\b/i,
+  /\bplease\s+(use|avoid|keep|make)\b/i,
+  /\bstyle[:\s]/i,
+  /\bformat[:\s]/i,
+  /\blanguage[:\s]/i,
+];
+
+export const extractPreferences = (blocks: NormalizedBlock[]): string[] => {
+  const prefs: string[] = [];
+
+  for (const b of blocks) {
+    if (b.kind !== "user") continue;
+    for (const line of nonEmptyLines(b.text)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.length < 5) continue;
+      if (PREF_PATTERNS.some((p) => p.test(trimmed))) {
+        prefs.push(clip(trimmed, 200));
+      }
+    }
+  }
+
+  return [...new Set(prefs)].slice(0, 10);
+};