omp-vcc 0.1.0

package/extensions/vcc-core/core/rank.ts

@@ -0,0 +1,284 @@
+// @ts-nocheck
+import type { NormalizedBlock, FileOps } from "../types";
+import { extractPath } from "./tool-args";
+import { compileBrief, heredocCloseIndex } from "./brief";
+
+export interface BriefRankingOptions {
+  /** Maximum normalized blocks used to build the brief transcript. */
+  maxBlocks?: number;
+  /** Always keep this many latest blocks to preserve local continuity. */
+  preserveRecentBlocks?: number;
+  /** Hook-provided file activity, used as structural signal instead of prose guessing. */
+  fileOps?: FileOps;
+  /**
+   * Optional size budget (in characters of rendered brief) for the selected
+   * blocks. When set, this is the PRIMARY limit: blocks are added by score
+   * until the budget is reached, and lower-value blocks are skipped rather
+   * than truncating the tail. maxBlocks still applies as a safety upper bound.
+   * Callers derive this from a token budget via charsPerToken.
+   * When maxBriefCharsCeiling + briefCharsPerBlock are also set, this acts as
+   * the FLOOR of a size-relative budget (see below).
+   */
+  maxBriefChars?: number;
+  /**
+   * Optional upper bound for a size-relative char budget. When set together
+   * with maxBriefChars (floor) and briefCharsPerBlock (slope), the effective
+   * budget becomes clamp(briefCharsPerBlock * blockCount, maxBriefChars,
+   * maxBriefCharsCeiling): larger transcripts (which carry more high-value
+   * long-tail -- edits, commands, tests) get more brief budget, while small
+   * sessions stay at the floor and this hard ceiling prevents unbounded growth.
+   */
+  maxBriefCharsCeiling?: number;
+  /** Per-block slope (chars) for the size-relative budget. Requires the ceiling. */
+  briefCharsPerBlock?: number;
+}
+
+export interface RankedBlock {
+  block: NormalizedBlock;
+  index: number;
+  score: number;
+  reasons: string[];
+}
+
+const DEFAULT_MAX_BLOCKS = 80;
+const DEFAULT_RECENT_BLOCKS = 16;
+
+const EDIT_TOOL_RE = /^(edit|write|multiedit|quick_edit|target_edit|apply_patch)$/i;
+const READ_TOOL_RE = /^(read|glob|grep|ls|find|semantic_query|semantic_grep|semantic_show)$/i;
+const TEST_COMMAND_RE = /\b(?:bun|npm|pnpm|yarn|node|pytest|cargo|go|mvn|gradle)\b[^\n]*(?:test|spec|check|lint|build|tsc)/i;
+const GH_PR_POLL_RE = /(?:^|\s)gh\s+pr\s+(?:view|checks)\s+(\d+)\b/i;
+// Durable workflow facts: which PR/issue was acted on, and git state changes.
+// Structural (command shape), not prose — same spirit as TEST_COMMAND_RE.
+const WORKFLOW_COMMAND_RE =
+  /(?:^|\s)(?:gh\s+(?:pr|issue)\s+[a-z-]+|git\s+(?:commit|push|merge|rebase|revert|cherry-pick|tag|reset|checkout|branch)\b)/i;
+const MIN_SEGMENT_CLOSING_ASSISTANT_CHARS = 120;
+
+// A bash block whose every meaningful line is pure scaffolding (set -e, cd,
+// export, ls, echo, sleep, pwd, comments, heredoc bodies) carries no durable
+// fact. Such blocks get a score penalty so the size-relative budget never
+// pulls them in ahead of real edits/commands when spare chars appear.
+const TRIVIAL_BASH_LINE_RE =
+  /^(?:set\s+[-+]|cd(?:\s+\S+)?$|export\s+\w+=|(?:source|\.)\s+\S+|pwd$|true$|:$|#|ls(?:\s|$)|echo\b|clear$|sleep\b)/;
+const TRIVIAL_BASH_PENALTY = 16;
+
+const isTrivialOnlyBash = (raw: string): boolean => {
+  const lines = raw.split("\n");
+  const kept: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    kept.push(lines[i]);
+    // Skip heredoc bodies (they are content, not scaffolding) using the same
+    // hardened detection as brief.ts: only skip when the terminator exists
+    // downstream, so a stray `<<` never swallows a later real command.
+    const close = heredocCloseIndex(lines, i);
+    if (close !== -1) i = close;
+  }
+  const meaningful = kept.map((l) => l.trim()).filter(Boolean).filter((l) => !TRIVIAL_BASH_LINE_RE.test(l));
+  return meaningful.length === 0;
+};
+
+const asPathSet = (paths?: string[]): Set<string> => new Set((paths ?? []).filter(Boolean));
+
+const bashCommandFromBlock = (block: NormalizedBlock): string | undefined => {
+  if (block.kind === "bash") return block.command;
+  if (block.kind === "tool_call" && /^bash$/i.test(block.name) && typeof block.args.command === "string") {
+    return block.args.command;
+  }
+  return undefined;
+};
+
+const pathFromBlock = (block: NormalizedBlock): string | undefined => {
+  if (block.kind === "tool_call") return extractPath(block.args) ?? undefined;
+  if (block.kind === "bash") {
+    const match = block.command.match(/(?:^|\s)([\w./-]+\.[\w-]+)(?:\s|$)/);
+    return match?.[1];
+  }
+  return undefined;
+};
+
+const add = (ranked: RankedBlock, points: number, reason: string) => {
+  ranked.score += points;
+  ranked.reasons.push(reason);
+};
+
+const scoreBlock = (
+  block: NormalizedBlock,
+  index: number,
+  total: number,
+  modifiedFiles: Set<string>,
+  readFiles: Set<string>,
+): RankedBlock => {
+  const ranked: RankedBlock = { block, index, score: 0, reasons: [] };
+  const recency = total <= 1 ? 0 : Math.round((index / (total - 1)) * 12);
+  add(ranked, recency, "recency");
+
+  if (block.kind === "user") add(ranked, 18, "user-turn");
+  if (block.kind === "assistant") add(ranked, 10, "assistant-context");
+  if (block.kind === "tool_result") add(ranked, 1, "tool-result-low-value");
+
+  if (block.kind === "tool_call") {
+    const command = bashCommandFromBlock(block);
+    if (EDIT_TOOL_RE.test(block.name)) add(ranked, 34, "edit-tool");
+    else if (command && TEST_COMMAND_RE.test(command)) add(ranked, 26, "test-command");
+    else if (READ_TOOL_RE.test(block.name)) add(ranked, 6, "read-tool");
+    else add(ranked, 12, "tool-call");
+    if (command && WORKFLOW_COMMAND_RE.test(command)) add(ranked, 14, "workflow-command");
+    if (command && isTrivialOnlyBash(command)) add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
+  }
+
+  if (block.kind === "bash") {
+    add(ranked, 8, "bash");
+    if (block.exitCode != null && block.exitCode !== 0) add(ranked, 24, "nonzero-exit");
+    if (TEST_COMMAND_RE.test(block.command)) add(ranked, 22, "test-command");
+    if (WORKFLOW_COMMAND_RE.test(block.command)) add(ranked, 14, "workflow-command");
+    // Penalize scaffolding-only commands, but not ones that failed (a failed
+    // `ls`/`cd` still records a real state fact via nonzero-exit).
+    if (isTrivialOnlyBash(block.command) && !(block.exitCode != null && block.exitCode !== 0)) {
+      add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
+    }
+  }
+
+  const path = pathFromBlock(block);
+  if (path) {
+    if (modifiedFiles.has(path)) add(ranked, 18, "hook-modified-file");
+    if (readFiles.has(path)) add(ranked, 6, "hook-read-file");
+  }
+
+  if (block.kind === "tool_result" && block.text.length > 1000) add(ranked, -8, "long-tool-result");
+  return ranked;
+};
+
+const boostAdjacency = (ranked: RankedBlock[]) => {
+  const important = ranked
+    .filter((r) => r.score >= 34 || r.reasons.includes("edit-tool") || r.reasons.includes("test-command") || r.reasons.includes("nonzero-exit"))
+    .map((r) => r.index);
+
+  for (const idx of important) {
+    for (let i = idx - 1; i >= Math.max(0, idx - 8); i--) {
+      if (ranked[i].block.kind === "user") {
+        add(ranked[i], 10, "near-important-event");
+        break;
+      }
+    }
+    for (let i = idx - 1; i >= Math.max(0, idx - 4); i--) {
+      if (ranked[i].block.kind === "assistant") {
+        add(ranked[i], 7, "near-important-event");
+        break;
+      }
+    }
+    for (let i = idx + 1; i <= Math.min(ranked.length - 1, idx + 4); i++) {
+      if (ranked[i].block.kind === "assistant" || ranked[i].block.kind === "bash") {
+        add(ranked[i], 5, "after-important-event");
+        break;
+      }
+    }
+  }
+};
+
+const nextNonToolResult = (ranked: RankedBlock[], index: number): NormalizedBlock | undefined => {
+  for (let i = index + 1; i < ranked.length; i++) {
+    if (ranked[i].block.kind !== "tool_result") return ranked[i].block;
+  }
+  return undefined;
+};
+
+const boostSegmentClosingAssistants = (ranked: RankedBlock[]) => {
+  for (let i = 0; i < ranked.length; i++) {
+    const current = ranked[i];
+    if (current.block.kind !== "assistant") continue;
+    if (current.block.text.trim().length < MIN_SEGMENT_CLOSING_ASSISTANT_CHARS) continue;
+    const next = nextNonToolResult(ranked, i);
+    if (!next || next.kind === "user") {
+      add(current, 14, "segment-closing-assistant");
+    }
+  }
+};
+
+const dedupKey = (block: NormalizedBlock): string | undefined => {
+  const command = bashCommandFromBlock(block);
+  const ghPrPoll = command?.match(GH_PR_POLL_RE);
+  if (ghPrPoll) return `gh-pr-poll:${ghPrPoll[1]}`;
+  if (command) {
+    const normalized = command.replace(/\s+/g, " ").trim();
+    return normalized ? `bash:${normalized}` : undefined;
+  }
+  if (block.kind === "tool_call") {
+    const path = pathFromBlock(block);
+    return path ? `tool:${block.name.toLowerCase()}:${path}` : undefined;
+  }
+  return undefined;
+};
+
+export const rankBriefBlocks = (blocks: NormalizedBlock[], options: BriefRankingOptions = {}): RankedBlock[] => {
+  const modifiedFiles = asPathSet(options.fileOps?.modifiedFiles);
+  const readFiles = asPathSet(options.fileOps?.readFiles);
+  const ranked = blocks.map((block, index) => scoreBlock(block, index, blocks.length, modifiedFiles, readFiles));
+  boostAdjacency(ranked);
+  boostSegmentClosingAssistants(ranked);
+  return ranked;
+};
+
+export const selectRankedBriefBlocks = (
+  blocks: NormalizedBlock[],
+  options: BriefRankingOptions = {},
+): NormalizedBlock[] => {
+  const maxBlocks = options.maxBlocks ?? DEFAULT_MAX_BLOCKS;
+  // Size-relative budget: when a ceiling + slope are provided, the effective
+  // char budget scales with transcript length (block count) between the floor
+  // (maxBriefChars) and the ceiling. Larger transcripts carry more high-value
+  // long-tail, so they earn more brief budget; small sessions stay at the floor.
+  const maxBriefChars =
+    options.maxBriefChars != null && options.maxBriefCharsCeiling != null && options.briefCharsPerBlock != null
+      ? Math.round(
+          Math.min(
+            options.maxBriefCharsCeiling,
+            Math.max(options.maxBriefChars, options.briefCharsPerBlock * blocks.length),
+          ),
+        )
+      : options.maxBriefChars;
+  // Fast path: nothing to trim by count and no char budget to enforce.
+  if (blocks.length <= maxBlocks && maxBriefChars == null) return blocks;
+
+  const preserveRecentBlocks = Math.min(options.preserveRecentBlocks ?? DEFAULT_RECENT_BLOCKS, maxBlocks);
+  const ranked = rankBriefBlocks(blocks, options);
+  const selected = new Set<number>();
+  const seenKeys = new Set<string>();
+
+  // Per-block rendered size, only computed when a char budget is active.
+  const costs = maxBriefChars == null
+    ? null
+    : blocks.map((b) => (b.kind === "tool_result" ? 0 : compileBrief([b]).length + 1));
+  let usedChars = 0;
+
+  // Keep the latest blocks to preserve local continuity, iterating NEWEST first
+  // so the most recent context is guaranteed. When a char budget is active these
+  // are charged against it too and over-budget blocks are skipped -- otherwise a
+  // run of large recent blocks could blow past maxBriefChars (the old bug on very
+  // long transcripts, where preserve-recent alone exceeded the budget).
+  for (let i = blocks.length - 1; i >= Math.max(0, blocks.length - preserveRecentBlocks); i--) {
+    if (blocks[i].kind === "tool_result") continue;
+    if (selected.has(i)) continue;
+    if (costs && usedChars + costs[i] > maxBriefChars!) continue;
+    selected.add(i);
+    if (costs) usedChars += costs[i];
+    const key = dedupKey(blocks[i]);
+    if (key) seenKeys.add(key);
+  }
+
+  const ordered = [...ranked].sort((a, b) => b.score - a.score || b.index - a.index);
+  for (const item of ordered) {
+    if (selected.size >= maxBlocks) break;
+    if (selected.has(item.index)) continue;
+    if (item.block.kind === "tool_result") continue;
+    const key = dedupKey(item.block);
+    if (key && seenKeys.has(key)) continue;
+    if (costs) {
+      // Skip (not break) so smaller high-value blocks can still fit the budget.
+      if (usedChars + costs[item.index] > maxBriefChars!) continue;
+      usedChars += costs[item.index];
+    }
+    selected.add(item.index);
+    if (key) seenKeys.add(key);
+  }
+
+  return [...selected].sort((a, b) => a - b).map((i) => blocks[i]);
+};

package/extensions/vcc-core/core/recall-scope.ts

@@ -0,0 +1,31 @@
+// @ts-nocheck
+export type RecallScope = "lineage" | "all";
+export type RecallMode = "hybrid" | "touched";
+
+const SCOPE_RE = /\bscope:(lineage|all)\b/i;
+
+const VALID_MODES = new Set(["hybrid", "touched"]);
+
+export const normalizeRecallScope = (scope?: unknown): RecallScope =>
+  typeof scope === "string" && scope.toLowerCase() === "all" ? "all" : "lineage";
+
+/**
+ * Normalize a mode param to a supported recall mode. Without OM integration,
+ * only "touched" adds behavior beyond the default hybrid search — "file"-only
+ * search is not implemented in pi-vcc, so it is not exposed.
+ *
+ * Ported from pi-blackhole (https://github.com/k0valik/pi-blackhole, MIT) by
+ * k0valik — a pi-vcc derivative.
+ */
+export const normalizeRecallMode = (mode?: unknown): RecallMode =>
+  typeof mode === "string" && VALID_MODES.has(mode.toLowerCase())
+    ? (mode.toLowerCase() as RecallMode)
+    : "hybrid";
+
+export const parseRecallScope = (text: string): { scope: RecallScope; text: string } => {
+  const match = text.match(SCOPE_RE);
+  return {
+    scope: normalizeRecallScope(match?.[1]),
+    text: text.replace(SCOPE_RE, "").replace(/\s+/g, " ").trim(),
+  };
+};

package/extensions/vcc-core/core/render-entries.ts

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import type { Message } from "@oh-my-pi/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 (!content || 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 (!content || 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 text = full ? textOf(msg.content) : clip(textOf(msg.content), 200);
+    return {
+      index, role: "tool_result",
+      summary: `[${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);
+  const summary = tools ? `${tools}\n${text}` : text;
+  return { index, role: "assistant", summary, ...(files.length > 0 && { files }) };
+};
+
+

package/extensions/vcc-core/core/report.ts

@@ -0,0 +1,233 @@
+// @ts-nocheck
+import type { Message } from "@oh-my-pi/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";
+import { estimateTokensFromChars } from "./token-estimate";
+
+const SECTION_HEADERS = ["Session Goal", "Files And Changes", "Commits", "Outstanding Context"];
+
+interface RoleCounts {
+  user: number;
+  assistant: number;
+  toolResult: number;
+}
+
+interface BlockCounts {
+  user: number;
+  assistant: number;
+  toolCalls: number;
+  toolResults: 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;
+    blockersCount: number;
+    briefTranscriptLines: number;
+  };
+  compression: {
+    charsBefore: number;
+    charsAfter: number;
+    ratio: number;
+    messagesBefore: number;
+  };
+  recall: {
+    probes: RecallProbe[];
+  };
+}
+
+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,
+  };
+
+  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;
+  }
+
+  return counts;
+};
+
+const inputCharsOf = (messages: Message[]): number =>
+  messages
+    .map((msg, index) => renderMessage(msg, index, true).summary.length)
+    .reduce((sum, len) => sum + len, 0);
+
+const topFilesOf = (messages: Message[]): string[] => {
+  const files = new Set<string>();
+  for (const block of normalize(messages)) {
+    if (block.kind === "tool_call") {
+      for (const key of ["path", "file_path", "filePath", "file"]) {
+        const val = block.args[key];
+        if (typeof val === "string") { files.add(val); break; }
+      }
+    }
+  }
+  return [...files].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 =>
+  SECTION_HEADERS.filter((header) => summary.includes(`[${header}]`)).length;
+
+const briefLineCountOf = (summary: string): number => {
+  const sep = "\n\n---\n\n";
+  const idx = summary.indexOf(sep);
+  if (idx < 0) return 0;
+  return summary.slice(idx + sep.length).split("\n").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): RecallProbe[] => {
+  const blocks = normalize(messages);
+  const data = buildSections({ blocks });
+
+  // Find first file from tool calls
+  let firstFile = "";
+  for (const b of blocks) {
+    if (b.kind === "tool_call") {
+      for (const key of ["path", "file_path", "filePath", "file"]) {
+        if (typeof b.args[key] === "string") { firstFile = b.args[key] as string; break; }
+      }
+      if (firstFile) break;
+    }
+  }
+
+  const rawProbes = [
+    { label: "goal", text: data.sessionGoal[0] ?? "" },
+    { label: "file", text: firstFile },
+    { label: "problem", text: data.outstandingContext[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, messages, 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) });
+  const inputChars = inputCharsOf(input.messages);
+  const topFiles = topFilesOf(input.messages);
+
+  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,
+      blockersCount: data.outstandingContext.length,
+      briefTranscriptLines: briefLineCountOf(summary),
+    },
+    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),
+    },
+  };
+};

package/extensions/vcc-core/core/sanitize.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+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, "");