omp-vcc 0.1.13 → 0.1.14

package/extensions/vcc-core/core/global-indices.ts

@@ -0,0 +1,46 @@
+// @ts-nocheck
+
+/** Minimal persisted-session entry shape used by the global index. */
+export interface PersistedSessionEntry {
+  type?: unknown;
+  id?: unknown;
+}
+
+/** A fail-closed mapping from unique message entry IDs to global positions. */
+export interface GlobalIndex {
+  /** Number of persisted entries whose type is exactly "message". */
+  messageCount: number;
+  /** Unique, non-empty string message IDs mapped to 1-based global positions. */
+  indexById: Map<string, number>;
+}
+
+/**
+ * Build global message positions from persisted session entries.
+ *
+ * Every message entry consumes a position, including entries without an ID.
+ * A repeated ID is removed permanently: malformed branches must not resolve
+ * to either occurrence. Missing and non-string IDs never enter the map.
+ */
+export const buildGlobalIndex = (
+  entries: Iterable<PersistedSessionEntry>,
+): GlobalIndex => {
+  const indexById = new Map<string, number>();
+  const seenIds = new Set<string>();
+  let messageCount = 0;
+
+  for (const entry of entries) {
+    if (entry?.type !== "message") continue;
+    messageCount++;
+
+    const id = entry.id;
+    if (typeof id !== "string" || id.length === 0 || seenIds.has(id)) {
+      if (typeof id === "string" && id.length > 0) indexById.delete(id);
+      continue;
+    }
+
+    seenIds.add(id);
+    indexById.set(id, messageCount);
+  }
+
+  return { messageCount, indexById };
+};

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

@@ -1,44 +1,139 @@
 // @ts-nocheck
-import { readFileSync } from "fs";
+import { statSync } from "fs";
 import type { Message } from "@oh-my-pi/pi-ai";
-import { renderMessage, type RenderedEntry } from "./render-entries";
+import { renderMessage, type RenderedEntry } from "./render-entries.ts";
+import { scanSessionEntries } from "./session-lines.ts";
 
 export interface LoadedMessages {
   rendered: RenderedEntry[];
   rawMessages: Message[];
+  /** Entry IDs aligned with rendered/rawMessages; missing IDs use an empty sentinel. */
+  entryIds: string[];
 }
 
+export interface LoadMessagesDebugEvent {
+  kind: "session-parse-errors";
+  sessionFile: string;
+  parseErrors: number;
+}
+
+export type LoadMessagesDebugSink = (event: LoadMessagesDebugEvent) => void;
+
+const CACHE_TTL_MS = 2_000;
+const CACHE_CAPACITY = 3;
+
+interface CacheEntry {
+  createdAt: number;
+  mtimeMs: number;
+  value: LoadedMessages;
+}
+
+const cache = new Map<string, CacheEntry>();
+
+const cacheKey = (
+  sessionFile: string,
+  full: boolean,
+  allowedEntryIds?: Set<string>,
+): string => {
+  const lineage = allowedEntryIds
+    ? JSON.stringify(Array.from(allowedEntryIds).sort())
+    : "*";
+  return JSON.stringify([sessionFile, full, lineage]);
+};
+
+const cached = (
+  key: string,
+  now: number,
+  mtimeMs: number,
+): LoadedMessages | undefined => {
+  const hit = cache.get(key);
+  if (!hit) return undefined;
+  if (now - hit.createdAt >= CACHE_TTL_MS || hit.mtimeMs !== mtimeMs) {
+    cache.delete(key);
+    return undefined;
+  }
+
+  // Refresh insertion order for the three-entry LRU.
+  cache.delete(key);
+  cache.set(key, hit);
+  return hit.value;
+};
+
+const remember = (key: string, value: LoadedMessages, mtimeMs: number): void => {
+  cache.delete(key);
+  cache.set(key, { createdAt: Date.now(), mtimeMs, value });
+  if (cache.size > CACHE_CAPACITY) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) cache.delete(oldest);
+  }
+};
+
+const emitParseDiagnostic = (
+  sink: LoadMessagesDebugSink | undefined,
+  sessionFile: string,
+  parseErrors: number,
+): void => {
+  if (!sink || parseErrors === 0) return;
+  try {
+    sink({
+      kind: "session-parse-errors",
+      sessionFile: sessionFile.slice(0, 1_024),
+      parseErrors,
+    });
+  } catch {
+    // Diagnostics must never affect session loading.
+  }
+};
+
 export const loadAllMessages = (
   sessionFile: string,
   full: boolean,
   allowedEntryIds?: Set<string>,
+  debugSink?: LoadMessagesDebugSink,
 ): LoadedMessages => {
-  let content: string;
+  const key = cacheKey(sessionFile, full, allowedEntryIds);
+  let mtimeMs: number | undefined;
   try {
-    content = readFileSync(sessionFile, "utf-8");
+    mtimeMs = statSync(sessionFile).mtimeMs;
   } catch {
-    return { rendered: [], rawMessages: [] };
+    // The scanner below preserves the existing empty-result behavior for
+    // missing/unreadable files while distinguishing ENOENT for its own callers.
   }
-  const entries: any[] = [];
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue;
-    try { entries.push(JSON.parse(line)); } catch {}
+
+  if (mtimeMs !== undefined) {
+    const hit = cached(key, Date.now(), mtimeMs);
+    if (hit) return hit;
   }
+
   const rendered: RenderedEntry[] = [];
   const rawMessages: Message[] = [];
-
+  const entryIds: string[] = [];
   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++;
+  let parseErrors = 0;
+  let missing = false;
+
+  try {
+    const scan = scanSessionEntries<any>(sessionFile, (entry) => {
+      if (entry?.type !== "message") return;
+
+      if (entry.message) {
+        const allowed = !allowedEntryIds || allowedEntryIds.has(entry.id);
+        if (allowed) {
+          rendered.push(renderMessage(entry.message, messageIndex, full));
+          rawMessages.push(entry.message);
+          entryIds.push(typeof entry.id === "string" ? entry.id : "");
+        }
+      }
+      messageIndex++;
+    });
+    missing = scan.missing;
+    parseErrors = scan.parseErrors;
+  } catch {
+    return { rendered: [], rawMessages: [], entryIds: [] };
   }
 
-  return { rendered, rawMessages };
+  emitParseDiagnostic(debugSink, sessionFile, parseErrors);
+  const value = { rendered, rawMessages, entryIds };
+  if (!missing && mtimeMs !== undefined) remember(key, value, mtimeMs);
+  return value;
 };

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

@@ -4,26 +4,26 @@ import type { NormalizedBlock } from "../types";
 import { textOf } from "./content";
 import { sanitize } from "./sanitize";
 
-const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
+const normalizeOne = (msg: Message, msgIndex: number, sourceIndex: number | undefined): NormalizedBlock[] => {
   if (msg.role === "user") {
     const blocks: NormalizedBlock[] = [];
     const text = sanitize(textOf(msg.content));
-    if (text) blocks.push({ kind: "user", text, sourceIndex: msgIndex });
+    if (text) blocks.push({ kind: "user", text, sourceIndex });
     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 });
+          blocks.push({ kind: "user", text: `[image: ${part.mimeType}]`, sourceIndex });
         }
       }
     }
-    return blocks.length > 0 ? blocks : [{ kind: "user", text: "", sourceIndex: msgIndex }];
+    return blocks.length > 0 ? blocks : [{ kind: "user", text: "", sourceIndex }];
   }
 
   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 }];
+    return [{ kind: "bash", command: cmd, output: out, exitCode: exit, sourceIndex }];
   }
 
   if (msg.role === "toolResult") {
@@ -31,29 +31,29 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
       kind: "tool_result",
       name: msg.toolName,
       text: sanitize(textOf(msg.content)),
-      sourceIndex: msgIndex,
+      sourceIndex,
     }];
   }
 
   if (msg.role === "assistant") {
     if (!msg.content) return [];
     if (typeof msg.content === "string") {
-      return [{ kind: "assistant", text: sanitize(msg.content), sourceIndex: msgIndex }];
+      return [{ kind: "assistant", text: sanitize(msg.content), sourceIndex }];
     }
 
     const blocks: NormalizedBlock[] = [];
     for (const part of msg.content) {
       if (part.type === "text") {
-        blocks.push({ kind: "assistant", text: sanitize(part.text), sourceIndex: msgIndex });
+        blocks.push({ kind: "assistant", text: sanitize(part.text), sourceIndex });
       } else if (part.type === "thinking") {
         const thinkingText = sanitize(part.text ?? part.thinking ?? "");
-        if (thinkingText) blocks.push({ kind: "thinking", text: thinkingText, sourceIndex: msgIndex });
+        if (thinkingText) blocks.push({ kind: "thinking", text: thinkingText, sourceIndex });
       } else if (part.type === "toolCall") {
         blocks.push({
           kind: "tool_call",
           name: part.name,
           args: part.arguments,
-          sourceIndex: msgIndex,
+          sourceIndex,
         });
       }
     }
@@ -65,14 +65,14 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
   // user or assistant turn. branchSummary entries carry no content here.
   if (msg.role === "custom") {
     const text = sanitize(textOf(msg.content));
-    if (text) return [{ kind: "custom", text, sourceIndex: msgIndex }];
+    if (text) return [{ kind: "custom", text, sourceIndex }];
     return [];
   }
 
   return [];
 };
 
-export const normalize = (messages: Message[]): NormalizedBlock[] =>
-  messages.flatMap((msg, i) => normalizeOne(msg, i));
+export const normalize = (messages: Message[], sourceIndices?: Array<number | undefined>): NormalizedBlock[] =>
+  messages.flatMap((msg, i) => normalizeOne(msg, i, sourceIndices ? sourceIndices[i] : i));
 
 

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

@@ -0,0 +1,107 @@
+// @ts-nocheck
+/**
+ * Pure helpers for bounding model-facing recall responses. Human-facing
+ * commands deliberately do not call this module; their existing per-entry
+ * clips remain the boundary for those surfaces.
+ */
+
+export const DEFAULT_RECALL_RESPONSE_MAX_CHARS = 48_000;
+export const EXPAND_FLOOR_CHARS = 2_000;
+export const EXPAND_ENTRY_OVERHEAD = 200;
+
+export interface RecallBudgetBlock {
+  /** Stable entry/page number used in the continuation marker. */
+  id?: string | number;
+  text: string;
+  /** Optional human label, e.g. "entry #4" or "page 2". */
+  label?: string;
+}
+
+export interface CapRecallBlocksOptions {
+  header?: string;
+  /** Used instead of `entry` in the omitted-content marker. */
+  blockKind?: string;
+}
+
+/**
+ * Allocate a total expansion budget fairly across requested expansions.
+ * The floor is honoured whenever the requested total can afford it; smaller
+ * budgets degrade proportionally, and the result never allocates more than
+ * the supplied budget. The per-entry overhead is reserved for separators and
+ * continuation bookkeeping.
+ */
+export const expandAllocation = (
+  totalChars: number,
+  count: number,
+  overhead = EXPAND_ENTRY_OVERHEAD,
+): number[] => {
+  if (!Number.isFinite(totalChars) || totalChars <= 0 || count <= 0) return [];
+  const safeCount = Math.max(1, Math.floor(count));
+  const safeOverhead = Number.isFinite(overhead) && overhead > 0 ? overhead : 0;
+  const available = Math.max(0, totalChars - safeOverhead * safeCount);
+  const share = Math.floor(available / safeCount);
+  const floorFits = share >= EXPAND_FLOOR_CHARS;
+  if (floorFits) {
+    const result = new Array<number>(safeCount).fill(EXPAND_FLOOR_CHARS);
+    let remainder = available - EXPAND_FLOOR_CHARS * safeCount;
+    for (let i = 0; i < safeCount && remainder > 0; i++) {
+      const extra = Math.min(remainder, share - EXPAND_FLOOR_CHARS);
+      result[i] += extra;
+      remainder -= extra;
+    }
+    return result;
+  }
+  return new Array<number>(safeCount).fill(share);
+};
+
+const blockLabel = (block: RecallBudgetBlock, index: number, kind: string): string => {
+  if (block.label) return block.label;
+  if (block.id !== undefined) return `${kind} ${block.id}`;
+  return `${kind} ${index + 1}`;
+};
+
+const asBlocks = (blocks: string[] | RecallBudgetBlock[]): RecallBudgetBlock[] =>
+  blocks.map((block) => (typeof block === "string" ? { text: block } : block));
+
+/**
+ * Cap a sequence of response blocks while retaining a bounded excerpt of
+ * every requested block. A zero budget is intentionally unbounded. The
+ * continuation marker is intentionally outside the nominal budget so callers
+ * can always explain why content was omitted.
+ */
+export const capRecallBlocks = (
+  blocks: Array<string | RecallBudgetBlock>,
+  maxChars = DEFAULT_RECALL_RESPONSE_MAX_CHARS,
+  options: CapRecallBlocksOptions = {},
+): string => {
+  const normalized = asBlocks(blocks);
+  if (maxChars === 0) {
+    return [options.header, ...normalized.map((b) => b.text)].filter(Boolean).join("\n\n");
+  }
+  if (normalized.length === 0) return options.header ?? "";
+
+  const limit = Number.isFinite(maxChars) ? Math.max(1, Math.floor(maxChars)) : DEFAULT_RECALL_RESPONSE_MAX_CHARS;
+  const header = options.header ?? "";
+  const bodyBudget = Math.max(0, limit - header.length);
+  const allocations = expandAllocation(bodyBudget, normalized.length);
+  const kind = options.blockKind ?? "entry";
+  const output: string[] = [];
+  const omitted: string[] = [];
+  for (let i = 0; i < normalized.length; i++) {
+    const block = normalized[i];
+    const allocation = allocations[i] ?? 0;
+    const text = block.text ?? "";
+    if (text.length <= allocation) {
+      output.push(text);
+    } else {
+      const excerpt = allocation > 0 ? text.slice(0, allocation) : "";
+      output.push(excerpt);
+      omitted.push(blockLabel(block, i, kind));
+    }
+  }
+  let result = [header, ...output].filter(Boolean).join("\n\n");
+  if (omitted.length > 0) {
+    result += `\n\n--- recall response capped at ${limit} characters; omitted ${kind}${omitted.length === 1 ? "" : "s"}: ${omitted.join(", ")} ---`;
+  }
+  return result;
+};

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

@@ -1,27 +1,34 @@
 // @ts-nocheck
 export type RecallScope = "lineage" | "all";
-export type RecallMode = "hybrid" | "touched";
+export type RecallMode = "hybrid" | "touched" | "file";
 
 const SCOPE_RE = /\bscope:(lineage|all)\b/i;
 
-const VALID_MODES = new Set(["hybrid", "touched"]);
+const VALID_MODES: Record<string, true> = { hybrid: true, touched: true, file: true };
 
 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.
+ * Normalize a mode param to a supported recall mode. `file` searches only
+ * content-bearing file tool-call arguments and excludes shell output.
  */
 export const normalizeRecallMode = (mode?: unknown): RecallMode =>
-  typeof mode === "string" && VALID_MODES.has(mode.toLowerCase())
+  typeof mode === "string" && VALID_MODES[mode.toLowerCase()]
     ? (mode.toLowerCase() as RecallMode)
     : "hybrid";
 
+const MODE_RE = /\bmode:(hybrid|touched|file)\b/i;
+
+/** Parse and remove a command/tool mode selector without changing query text. */
+export const parseRecallMode = (text: string): { mode?: RecallMode; text: string } => {
+  const match = text.match(MODE_RE);
+  return {
+    mode: match?.[1] ? normalizeRecallMode(match[1]) : undefined,
+    text: text.replace(MODE_RE, "").replace(/\s+/g, " ").trim(),
+  };
+};
+
 export const parseRecallScope = (text: string): { scope: RecallScope; text: string } => {
   const match = text.match(SCOPE_RE);
   return {