omp-vcc 0.1.0

package/extensions/vcc-core/core/drill-down.ts

@@ -0,0 +1,299 @@
+// @ts-nocheck
+/**
+ * Drill-down: resolve #N:path syntax to tool call file content.
+ *
+ * Ported from pi-blackhole (https://github.com/k0valik/pi-blackhole, MIT) by
+ * k0valik — a pi-vcc derivative.
+ *
+ * Supports: #42:auth.ts (preview), #42:auth.ts:full (full content), #42:file (auto-select).
+ *
+ * Path matching notes:
+ * - The regex uses $ anchor so lazy .+? consumes the full path — spaces, dots, and
+ *   Windows drive-letter colons (C:\) all work correctly.
+ * - One edge case: a file path literally ending in ":full" (e.g. C:\file:full)
+ *   would be misinterpreted as the :full flag. This is extremely unlikely.
+ * - Inline queries like "check #42:auth.ts" are NOT drill-down — the ^ anchor
+ *   requires the entire query to be the drill-down pattern.
+ */
+import { isContentBearing } from "./content";
+import { extractPath } from "./tool-args";
+import { loadAllMessages } from "./load-messages";
+
+// ── Types ─────────────────────────────────────────────────────────────────
+
+interface ContentBearingCall {
+  name: string;
+  path: string;
+  content?: string;
+  oldText?: string;
+  newText?: string;
+  edits?: Array<{ oldText?: string; newText?: string }>;
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+/**
+ * Find content-bearing tool calls that have a `path` argument and at least
+ * one content field (content, edits, oldText, newText).
+ * Uses the shared isContentBearing() heuristic from content.ts.
+ */
+function findContentBearingCalls(content: unknown[]): ContentBearingCall[] {
+  if (!Array.isArray(content)) return [];
+  const results: ContentBearingCall[] = [];
+  for (const part of content) {
+    if (!part || (part as any).type !== "toolCall") continue;
+    const args = (part as any).arguments ?? {};
+    if (!isContentBearing(args)) continue;
+    const path = extractPath(args);
+    if (!path) continue;
+    const entry: ContentBearingCall = { name: (part as any).name ?? "", path };
+    if (typeof args.content === "string") entry.content = args.content;
+    if (Array.isArray(args.edits)) {
+      entry.edits = args.edits.filter(
+        (e: unknown): e is { oldText?: string; newText?: string } =>
+          e !== null && typeof e === "object",
+      );
+    }
+    if (typeof args.oldText === "string" && !Array.isArray(args.edits))
+      entry.oldText = args.oldText;
+    if (typeof args.newText === "string" && !Array.isArray(args.edits))
+      entry.newText = args.newText;
+    results.push(entry);
+  }
+  return results;
+}
+
+/** Format content for display with optional offset/limit slicing.
+ *
+ * When full=true, shows everything ignoring offset/limit.
+ * When offset/limit given, shows a window with "Lines X-Y (of Z)" header.
+ * When neither, shows preview (first 30 lines) with truncation hint.
+ */
+function formatToolCallContent(
+  tc: ContentBearingCall,
+  entryIndex: number,
+  options?: { full?: boolean; offset?: number; limit?: number },
+): string {
+  let body: string;
+  if (tc.content) {
+    body = tc.content;
+  } else if (tc.edits) {
+    body = tc.edits
+      .map(
+        (e, i) =>
+          `--- edit ${i + 1} ---\n${e.oldText ?? ""}\n--- becomes ---\n${e.newText ?? ""}`,
+      )
+      .join("\n\n");
+  } else if (tc.oldText && tc.newText) {
+    body = `--- old ---\n${tc.oldText}\n--- new ---\n${tc.newText}`;
+  } else {
+    body = "(no file content found in tool call arguments)";
+  }
+
+  const full = options?.full ?? false;
+  const offset = options?.offset;
+  const limit = options?.limit;
+  const allLines = body.split("\n");
+  const totalLines = allLines.length;
+  const previewLimit = 30;
+  const MAX_FULL_BYTES = 50 * 1024;
+
+  if (full) {
+    // Full content: capped at 50KB
+    if (Buffer.byteLength(body, "utf8") > MAX_FULL_BYTES) {
+      const truncated = body.slice(0, MAX_FULL_BYTES);
+      return `File: ${tc.path}
+Tool: ${tc.name}
+
+${truncated}
+
+... (${Buffer.byteLength(body, "utf8") - MAX_FULL_BYTES} more bytes — file exceeds 50KB display limit. Use #${entryIndex}:${tc.path}:${previewLimit} for next page.)`;
+    }
+    return `File: ${tc.path}
+Tool: ${tc.name}
+
+${body}`;
+  }
+
+  if (offset !== undefined) {
+    // Offset-based window: show slice
+    const startLine = Math.max(0, offset);
+    const maxLines = limit ?? 30;
+    const endLine = Math.min(startLine + maxLines, totalLines);
+    const visible = allLines.slice(startLine, endLine);
+    const displayStart = startLine + 1; // 1-indexed for user display
+
+    if (visible.length === 0) {
+      return `Offset ${startLine} is beyond file length ${totalLines}. Use #${entryIndex}:${tc.path} for the first ${previewLimit} lines.`;
+    }
+
+    let result = `File: ${tc.path}
+Tool: ${tc.name}
+Lines ${displayStart}-${endLine} (of ${totalLines}):
+
+`;
+    result += visible.join("\n");
+
+    if (endLine < totalLines) {
+      result += `\n\n--- Use #${entryIndex}:${tc.path}:${endLine} or #${entryIndex}:${tc.path}:${endLine}:${maxLines} for next ${maxLines} lines, #${entryIndex}:${tc.path}:full for complete ---`;
+    } else if (offset > 0) {
+      result += `\n\n(End of file)`;
+    }
+
+    return result;
+  }
+
+  // Default preview mode: first ${previewLimit} lines
+  if (totalLines > previewLimit) {
+    const preview = allLines.slice(0, previewLimit).join("\n");
+    return `File: ${tc.path}
+Tool: ${tc.name}
+
+${preview}
+
+...(${totalLines - previewLimit} more lines — use #${entryIndex}:${tc.path}:full for complete content, or #${entryIndex}:${tc.path}:${previewLimit} for next ${previewLimit} lines)`;
+  }
+
+  return `File: ${tc.path}
+Tool: ${tc.name}
+
+${body}`;
+}
+
+// ── Parse drill-down query ────────────────────────────────────────────────
+
+/**
+ * Pattern: #N:path, #N:path:full, #N:path:offset, or #N:path:offset:limit
+ * Group 1: index number
+ * Group 2: path (consumed lazily, expanded until suffix can match)
+ * Group 3: suffix — "full", a number (offset), or "offset:limit"
+ */
+const DRILLDOWN_PATTERN = /^#(\d+):(.+?)(?::(full|\d+(?::\d+)?))?$/;
+
+/**
+ * Parse a drill-down query like #42:auth.ts or #42:auth.ts:full.
+ * Returns null if the query doesn't match the drill-down pattern.
+ *
+ * Suffixes:
+ *   :full       → full content (no truncation)
+ *   :30         → offset 30 lines, default limit (30)
+ *   :30:20      → offset 30 lines, limit 20 lines
+ *   (none)      → preview first 30 lines
+ */
+export function parseDrillDown(query: string): {
+  index: number;
+  pathPattern: string;
+  full: boolean;
+  offset?: number;
+  limit?: number;
+} | null {
+  const match = query.match(DRILLDOWN_PATTERN);
+  if (!match) return null;
+  const index = parseInt(match[1], 10);
+  const pathPattern = match[2];
+  const suffix = match[3];
+
+  if (suffix === "full") {
+    return {
+      index,
+      pathPattern,
+      full: true,
+      offset: undefined,
+      limit: undefined,
+    };
+  }
+
+  if (suffix !== undefined) {
+    // Parse "offset" or "offset:limit"
+    const parts = suffix.split(":");
+    const offset = parseInt(parts[0], 10);
+    const limit = parts[1] !== undefined ? parseInt(parts[1], 10) : undefined;
+    if (!Number.isNaN(offset)) {
+      return { index, pathPattern, full: false, offset, limit };
+    }
+  }
+
+  return {
+    index,
+    pathPattern,
+    full: false,
+    offset: undefined,
+    limit: undefined,
+  };
+}
+
+// ── Main export ───────────────────────────────────────────────────────────
+
+/**
+ * Expand a drill-down query (#N:path) to tool call content.
+ *
+ * Offset/limit let you page through file content incrementally (like pi's read tool):
+ *   #42:auth.ts         → first 30 lines (preview)
+ *   #42:auth.ts:full    → all content
+ *   #42:auth.ts:30      → lines 31-60 (default limit 30)
+ *   #42:auth.ts:30:20   → lines 31-50 (custom limit 20)
+ *
+ * @param sessionFile - Path to the JSONL session file
+ * @param entryIndex - The message index (#N)
+ * @param pathPattern - File path substring to match (or "file" keyword)
+ * @param full - If true, return complete content without truncation
+ * @param offset - Line offset (0-indexed) for windowed content
+ * @param limit - Max lines to show (default 30 for windowed, ignored if full=true)
+ * @returns Formatted content string
+ */
+export function expandEntryFile(
+  sessionFile: string,
+  entryIndex: number,
+  pathPattern: string,
+  full = false,
+  offset?: number,
+  limit?: number,
+): string {
+  const { rawMessages } = loadAllMessages(sessionFile, true);
+
+  if (entryIndex < 0 || entryIndex >= rawMessages.length) {
+    return `Entry #${entryIndex} not found in session history.`;
+  }
+
+  const msg = rawMessages[entryIndex];
+  const content = msg.content as unknown[];
+  const calls = findContentBearingCalls(content);
+
+  // Special case: #42:file keyword
+  if (pathPattern === "file") {
+    if (calls.length === 0) {
+      return `No file content found in entry #${entryIndex}.`;
+    }
+    if (calls.length === 1) {
+      return formatToolCallContent(calls[0], entryIndex, {
+        full,
+        offset,
+        limit,
+      });
+    }
+    // Multiple content-bearing calls — list them
+    const items = calls.map(
+      (tc) => `  [#${entryIndex}:${tc.path}] ${tc.name}(${tc.path})`,
+    );
+    return `Entry #${entryIndex} has ${calls.length} file operations:\n${items.join("\n")}\n\nUse #${entryIndex}:path to drill into a specific file.`;
+  }
+
+  const matched = calls.filter((tc) => tc.path.includes(pathPattern));
+
+  if (matched.length === 0) {
+    return `No file content found in entry #${entryIndex} for "${pathPattern}".`;
+  }
+
+  if (matched.length > 1) {
+    // Ambiguous match — list options instead of silently picking the first
+    const items = matched.map(
+      (tc) => `  [#${entryIndex}:${tc.path}] ${tc.name}(${tc.path})`,
+    );
+    return `Entry #${entryIndex} has ${matched.length} file operations matching "${pathPattern}":
+${items.join("\n")}
+
+Use #${entryIndex}:<more-specific-path> to drill into a specific file.`;
+  }
+
+  return formatToolCallContent(matched[0], entryIndex, { full, offset, limit });
+}

package/extensions/vcc-core/core/filter-noise.ts

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import type { NormalizedBlock } from "../types";
+
+const NOISE_TOOLS = new Set([
+  "TodoWrite", "TodoRead", "ToolSearch", "WebSearch",
+  "AskUser", "ExitSpecMode", "GenerateDroid",
+]);
+
+const NOISE_STRINGS = [
+  "Continue from where you left off.",
+  "No response requested.",
+  "IMPORTANT: TodoWrite was not called yet.",
+];
+
+const XML_WRAPPER_RE = /<(system-reminder|ide_opened_file|command-message|context-window-usage)[^>]*>[\s\S]*?<\/\1>/g;
+
+const isNoiseUserBlock = (text: string): boolean => {
+  const trimmed = text.trim();
+  if (NOISE_STRINGS.some((s) => trimmed.includes(s))) return true;
+  const stripped = trimmed.replace(XML_WRAPPER_RE, "").trim();
+  return stripped.length === 0;
+};
+
+const cleanUserText = (text: string): string =>
+  text.replace(XML_WRAPPER_RE, "").trim();
+
+export const filterNoise = (blocks: NormalizedBlock[]): NormalizedBlock[] => {
+  const out: NormalizedBlock[] = [];
+  for (const b of blocks) {
+    if (b.kind === "tool_call" && NOISE_TOOLS.has(b.name)) continue;
+    if (b.kind === "tool_result" && NOISE_TOOLS.has(b.name)) continue;
+    if (b.kind === "user") {
+      if (isNoiseUserBlock(b.text)) continue;
+      const cleaned = cleanUserText(b.text);
+      if (!cleaned) continue;
+      out.push({ kind: "user", text: cleaned });
+      continue;
+    }
+    out.push(b);
+  }
+  return out;
+};

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

@@ -0,0 +1,101 @@
+// @ts-nocheck
+import type { SearchHit, TouchedFile } from "./search-entries";
+
+// ── Path shortening ───────────────────────────────────────────────────────
+
+const CWD = process.cwd();
+
+/**
+ * Shorten an absolute file path for display:
+ * - If within cwd, return `./relative/path`
+ * - Otherwise, show last 3 path components with `.../` prefix
+ * - Short paths (≤3 components) returned as-is
+ *
+ * Ported from pi-blackhole (https://github.com/k0valik/pi-blackhole, MIT) by
+ * k0valik — a pi-vcc derivative.
+ */
+export function shortPath(fullPath: string): string {
+  const normalized = fullPath.replace(/\\/g, "/");
+  const cwdNormalized = CWD.replace(/\\/g, "/");
+  if (normalized.startsWith(cwdNormalized + "/")) {
+    return "." + normalized.slice(cwdNormalized.length);
+  }
+  const parts = normalized.split("/");
+  if (parts.length > 3) {
+    return ".../" + parts.slice(-3).join("/");
+  }
+  return normalized;
+}
+
+// ── Touched file output ───────────────────────────────────────────────────
+
+export const TOUCHED_PAGE_SIZE = 5;
+
+/**
+ * Format aggregated "files touched" output.
+ *
+ * Ported from pi-blackhole (https://github.com/k0valik/pi-blackhole, MIT) by
+ * k0valik — a pi-vcc derivative.
+ */
+export function formatTouchedOutput(
+  touched: TouchedFile[],
+  page?: number,
+  pageSize?: number,
+): string {
+  if (touched.length === 0) {
+    return "No file operations found in session history.";
+  }
+
+  const ps = pageSize ?? TOUCHED_PAGE_SIZE;
+  const totalPages = Math.ceil(touched.length / ps);
+  const currentPage = Math.max(1, page ?? 1);
+  const start = (currentPage - 1) * ps;
+  const pageFiles = touched.slice(start, start + ps);
+
+  const header =
+    totalPages > 1
+      ? `Page ${currentPage}/${totalPages} (${touched.length} total files)`
+      : `${touched.length} files touched`;
+
+  const lines = pageFiles.map((tf) => {
+    const displayPath = shortPath(tf.path);
+    const indices = tf.entries
+      .map((e) => `#${e.index} (${e.toolName})`)
+      .join(", ");
+    return `  ${displayPath}    ${indices}`;
+  });
+
+  let result = `${header}:\n\n${lines.join("\n")}`;
+
+  if (currentPage < totalPages) {
+    result += `\n\n--- Use page:${currentPage + 1} for more results ---`;
+  }
+
+  return result;
+}
+
+export const formatRecallOutput = (
+  entries: SearchHit[],
+  query?: string,
+  headerOverride?: string,
+): string => {
+  if (entries.length === 0) {
+    return query
+      ? `No matches for "${query}" in session history.`
+      : "No entries in session history.";
+  }
+
+  const header = headerOverride
+    ? `${headerOverride} for "${query}":`
+    : query
+      ? `Found ${entries.length} matches for "${query}":`
+      : `Session history (${entries.length} entries):`;
+
+  const lines = entries.map((e) => {
+    const fileSuffix = e.files?.length ? ` files:[${e.files.join(", ")}]` : "";
+    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/extensions/vcc-core/core/format.ts

@@ -0,0 +1,82 @@
+// @ts-nocheck
+import type { SectionData } from "../sections";
+
+const section = (title: string, items: string[]): string => {
+  if (items.length === 0) return "";
+  const body = items.map((i) => `- ${i}`).join("\n");
+  return `[${title}]\n${body}`;
+};
+
+export const BRIEF_MAX_LINES = 120;
+const TUI_SAFE_LINE_CHARS = 120;
+
+const wrapLine = (line: string, maxChars: number): string[] => {
+  if (line.length <= maxChars) return [line];
+
+  const indent = line.match(/^\s*(?:[-*]\s+|\d+\.\s+)?/)?.[0] ?? "";
+  const continuationIndent = indent ? " ".repeat(Math.min(indent.length, 8)) : "";
+  const wrapped: string[] = [];
+  let remaining = line;
+  let prefix = "";
+
+  while (prefix.length + remaining.length > maxChars) {
+    const available = Math.max(20, maxChars - prefix.length);
+    let splitAt = remaining.lastIndexOf(" ", available);
+    if (splitAt < Math.floor(available * 0.5)) splitAt = available;
+
+    wrapped.push(prefix + remaining.slice(0, splitAt).trimEnd());
+    remaining = remaining.slice(splitAt).trimStart();
+    prefix = continuationIndent;
+  }
+
+  if (remaining) wrapped.push(prefix + remaining);
+  return wrapped;
+};
+
+export const wrapLongLines = (text: string, maxChars = TUI_SAFE_LINE_CHARS): string =>
+  text.split("\n").flatMap((line) => wrapLine(line, maxChars)).join("\n");
+
+export const capBrief = (text: string): string => {
+  const lines = text.split("\n");
+  if (lines.length <= BRIEF_MAX_LINES) return text;
+  const omitted = lines.length - BRIEF_MAX_LINES;
+  const kept = lines.slice(-BRIEF_MAX_LINES);
+  // Find first section header to avoid cutting mid-section
+  const firstHeader = kept.findIndex((l) => /^\[.+\]/.test(l));
+  const clean = firstHeader > 0 ? kept.slice(firstHeader) : kept;
+  return `...(${omitted} earlier lines omitted)\n\n${clean.join("\n")}`;
+};
+
+export const RECALL_NOTE =
+  "Use `vcc_recall` to search for prior work, decisions, and context from before this summary. " +
+  "Do not redo work already completed.";
+
+export interface FormatSummaryOptions {
+  capBriefTranscript?: boolean;
+}
+
+export const formatSummary = (data: SectionData, options: FormatSummaryOptions = {}): string => {
+  const capBriefTranscript = options.capBriefTranscript ?? true;
+  const headerParts = [
+    section("Session Goal", data.sessionGoal),
+    section("Files And Changes", data.filesAndChanges),
+    section("Commits", data.commits),
+    section("Outstanding Context", data.outstandingContext),
+    section("User Preferences", data.userPreferences),
+  ].filter(Boolean);
+
+  const parts: string[] = [];
+  if (headerParts.length > 0) {
+    parts.push(headerParts.join("\n\n"));
+  }
+  if (data.briefTranscript) {
+    parts.push(capBriefTranscript ? capBrief(data.briefTranscript) : data.briefTranscript);
+  }
+
+  if (parts.length === 0) return "";
+
+  // NOTE: RECALL_NOTE is intentionally NOT appended here.
+  // It is appended once by `compile()` at the very end, after merge-with-previous,
+  // to avoid the note compounding inside the brief transcript across compactions.
+  return wrapLongLines(parts.join("\n\n---\n\n"));
+};

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

@@ -0,0 +1,27 @@
+// @ts-nocheck
+export interface LineageEntryLike {
+  id?: string;
+}
+
+export interface LineageSessionManagerLike {
+  getBranch: () => LineageEntryLike[];
+  getEntries?: () => LineageEntryLike[];
+}
+
+export const getActiveLineageEntryIds = (sessionManager: LineageSessionManagerLike): Set<string> => {
+  try {
+    const branch = sessionManager.getBranch() ?? [];
+    if (branch.length > 0) {
+      return new Set(branch.map((e) => e.id).filter((id): id is string => Boolean(id)));
+    }
+  } catch {
+    // fall through to defensive fallback
+  }
+
+  try {
+    const all = sessionManager.getEntries?.() ?? [];
+    return new Set(all.map((e) => e.id).filter((id): id is string => Boolean(id)));
+  } catch {
+    return new Set();
+  }
+};

package/extensions/vcc-core/core/load-messages.ts

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { readFileSync } from "fs";
+import type { Message } from "@oh-my-pi/pi-ai";
+import { renderMessage, type RenderedEntry } from "./render-entries";
+
+export interface LoadedMessages {
+  rendered: RenderedEntry[];
+  rawMessages: Message[];
+}
+
+export const loadAllMessages = (
+  sessionFile: string,
+  full: boolean,
+  allowedEntryIds?: Set<string>,
+): LoadedMessages => {
+  let content: string;
+  try {
+    content = readFileSync(sessionFile, "utf-8");
+  } catch {
+    return { rendered: [], rawMessages: [] };
+  }
+  const entries: any[] = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try { entries.push(JSON.parse(line)); } catch {}
+  }
+  const rendered: RenderedEntry[] = [];
+  const rawMessages: Message[] = [];
+
+  let messageIndex = 0;
+  for (const e of entries) {
+    const isMessage = e.type === "message" && e.message;
+    if (!isMessage) continue;
+
+    const allowed = !allowedEntryIds || allowedEntryIds.has(e.id);
+    if (allowed) {
+      rendered.push(renderMessage(e.message, messageIndex, full));
+      rawMessages.push(e.message);
+    }
+    messageIndex++;
+  }
+
+  return { rendered, rawMessages };
+};

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

@@ -0,0 +1,66 @@
+// @ts-nocheck
+import type { Message } from "@oh-my-pi/pi-ai";
+import type { NormalizedBlock } from "../types";
+import { textOf } from "./content";
+import { sanitize } from "./sanitize";
+
+const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
+  if (msg.role === "user") {
+    const blocks: NormalizedBlock[] = [];
+    const text = sanitize(textOf(msg.content));
+    if (text) blocks.push({ kind: "user", text, sourceIndex: msgIndex });
+    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}]`, sourceIndex: msgIndex });
+        }
+      }
+    }
+    return blocks.length > 0 ? blocks : [{ kind: "user", text: "", sourceIndex: msgIndex }];
+  }
+
+  if (msg.role === "bashExecution") {
+    const cmd = (msg as any).command ?? "";
+    const out = (msg as any).output ?? "";
+    const exit = (msg as any).exitCode;
+    return [{ kind: "bash", command: cmd, output: out, exitCode: exit, sourceIndex: msgIndex }];
+  }
+
+  if (msg.role === "toolResult") {
+    return [{
+      kind: "tool_result",
+      name: msg.toolName,
+      text: sanitize(textOf(msg.content)),
+      sourceIndex: msgIndex,
+    }];
+  }
+
+  if (msg.role === "assistant") {
+    if (!msg.content) return [];
+    if (typeof msg.content === "string") {
+      return [{ kind: "assistant", text: sanitize(msg.content), sourceIndex: msgIndex }];
+    }
+
+    const blocks: NormalizedBlock[] = [];
+    for (const part of msg.content) {
+      if (part.type === "text") {
+        blocks.push({ kind: "assistant", text: sanitize(part.text), sourceIndex: msgIndex });
+      } else if (part.type === "toolCall") {
+        blocks.push({
+          kind: "tool_call",
+          name: part.name,
+          args: part.arguments,
+          sourceIndex: msgIndex,
+        });
+      }
+    }
+    return blocks;
+  }
+
+  return [];
+};
+
+export const normalize = (messages: Message[]): NormalizedBlock[] =>
+  messages.flatMap((msg, i) => normalizeOne(msg, i));
+
+