ultimate-pi 0.1.7 → 0.2.2

package/node_modules/@sting8k/pi-vcc/src/core/build-sections.ts

@@ -0,0 +1,79 @@
+import type { NormalizedBlock } from "../types";
+import { clip, clipSentence, firstLine, nonEmptyLines } from "./content";
+import type { SectionData } from "../sections";
+import { extractGoals } from "../extract/goals";
+import { extractFiles } from "../extract/files";
+import { extractPreferences, dedupPreferencesAgainstGoals } from "../extract/preferences";
+import { extractCommits, formatCommits } from "../extract/commits";
+import { buildBriefSections, sectionsToTranscript, stringifyBrief } from "./brief";
+
+export interface BuildSectionsInput {
+  blocks: NormalizedBlock[];
+}
+
+const BLOCKER_RE =
+  /\b(fail(ed|s|ure|ing)?|broken|cannot|can't|won't work|does not work|doesn't work|still (broken|failing|wrong)|blocked|blocker|not (fixed|resolved|working)|crash(es|ed|ing)?)\b/i;
+
+const extractOutstandingContext = (blocks: NormalizedBlock[]): string[] => {
+  const items: string[] = [];
+  const tail = blocks.slice(-20);
+
+  for (const b of tail) {
+    if (b.kind === "tool_result" && b.isError) {
+      items.push(`[${b.name}] ${firstLine(b.text, 150)}`);
+      continue;
+    }
+
+    if (b.kind === "assistant" || b.kind === "user") {
+      for (const line of nonEmptyLines(b.text)) {
+        if (!BLOCKER_RE.test(line)) continue;
+        if (line.length < 15) continue;
+        // Skip continuation fragments (sub-bullets, parentheticals, dangling clauses)
+        if (/^\s*[-*+>]\s/.test(line)) continue;
+        if (/^\s*\(/.test(line)) continue;
+        // Require sentence-like start: capital letter, code identifier, or quote
+        if (!/^\s*["'`*_]?[A-Z`]/.test(line)) continue;
+        const clipped = b.kind === "user" ? `[user] ${clipSentence(line, 150)}` : clipSentence(line, 150);
+        if (!items.includes(clipped)) items.push(clipped);
+        break;
+      }
+    }
+  }
+
+  return items.slice(0, 5);
+};
+
+const formatFileActivity = (blocks: NormalizedBlock[]): string[] => {
+  const act = extractFiles(blocks);
+  // Dedup: if already Modified, drop from Created (file existed before)
+  for (const p of act.modified) act.created.delete(p);
+  const lines: string[] = [];
+  const cap = (set: Set<string>, limit: number) => {
+    const arr = [...set];
+    if (arr.length <= limit) return arr.join(", ");
+    return arr.slice(0, limit).join(", ") + ` (+${arr.length - limit} more)`;
+  };
+  if (act.modified.size > 0) lines.push(`Modified: ${cap(act.modified, 10)}`);
+  if (act.created.size > 0) lines.push(`Created: ${cap(act.created, 10)}`);
+  if (act.read.size > 0) lines.push(`Read: ${cap(act.read, 10)}`);
+  return lines;
+};
+
+export const buildSections = (input: BuildSectionsInput): SectionData => {
+  const { blocks } = input;
+  const briefSections = buildBriefSections(blocks);
+  const sessionGoal = extractGoals(blocks);
+  const userPreferences = dedupPreferencesAgainstGoals(
+    extractPreferences(blocks),
+    sessionGoal,
+  );
+  return {
+    sessionGoal,
+    outstandingContext: extractOutstandingContext(blocks),
+    filesAndChanges: formatFileActivity(blocks),
+    commits: formatCommits(extractCommits(blocks)),
+    userPreferences,
+    briefTranscript: stringifyBrief(briefSections),
+    transcriptEntries: sectionsToTranscript(briefSections),
+  };
+};

package/node_modules/@sting8k/pi-vcc/src/core/content.ts

@@ -0,0 +1,60 @@
+import type { Message } from "@mariozechner/pi-ai";
+
+export const clip = (text: string, max = 200): string => {
+  if (text.length <= max) return text;
+  // Try to cut at a word boundary
+  const cut = text.lastIndexOf(" ", max);
+  let end = cut > max * 0.6 ? cut : max;
+  // Avoid splitting a surrogate pair
+  if (end > 0 && end < text.length) {
+    const code = text.charCodeAt(end - 1);
+    if (code >= 0xd800 && code <= 0xdbff) end--;
+  }
+  return text.slice(0, end);
+};
+
+/**
+ * Clip text to last sentence boundary at or before `max` chars.
+ * Falls back to word boundary (clip()) if no sentence end is found in the
+ * acceptable range. Trailing whitespace stripped.
+ */
+export const clipSentence = (text: string, max = 200): string => {
+  if (text.length <= max) return text;
+  // Look for sentence terminators followed by space/newline within [max*0.5, max]
+  const window = text.slice(0, max);
+  const matches = [...window.matchAll(/[.!?](?:\s|$)/g)];
+  if (matches.length > 0) {
+    const last = matches[matches.length - 1];
+    const end = (last.index ?? 0) + 1; // include the punctuation
+    if (end >= max * 0.5) return text.slice(0, end);
+  }
+  return clip(text, max);
+};
+
+export const nonEmptyLines = (text: string): string[] =>
+  text.split("\n").map((line) => line.trim()).filter(Boolean);
+
+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")
+    .map((part) => part.text);
+};
+
+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/node_modules/@sting8k/pi-vcc/src/core/filter-noise.ts

@@ -0,0 +1,42 @@
+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 === "thinking") continue;
+    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/node_modules/@sting8k/pi-vcc/src/core/format-recall.ts

@@ -0,0 +1,27 @@
+import type { SearchHit } from "./search-entries";
+
+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/node_modules/@sting8k/pi-vcc/src/core/format.ts

@@ -0,0 +1,49 @@
+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}`;
+};
+
+const BRIEF_MAX_LINES = 120;
+
+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 const formatSummary = (data: SectionData): string => {
+  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(capBrief(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 parts.join("\n\n---\n\n");
+};

package/node_modules/@sting8k/pi-vcc/src/core/lineage.ts

@@ -0,0 +1,26 @@
+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/node_modules/@sting8k/pi-vcc/src/core/load-messages.ts

@@ -0,0 +1,41 @@
+import { readFileSync } from "fs";
+import type { Message } from "@mariozechner/pi-ai";
+import { renderMessage, type RenderedEntry } from "./render-entries";
+
+export interface LoadedMessages {
+  rendered: RenderedEntry[];
+  rawMessages: Message[];
+  entryIds: string[];
+}
+
+export const loadAllMessages = (
+  sessionFile: string,
+  full: boolean,
+  allowedEntryIds?: Set<string>,
+): LoadedMessages => {
+  const content = readFileSync(sessionFile, "utf-8");
+  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[] = [];
+  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);
+      entryIds.push(String(e.id));
+    }
+    messageIndex++;
+  }
+
+  return { rendered, rawMessages, entryIds };
+};

package/node_modules/@sting8k/pi-vcc/src/core/normalize.ts

@@ -0,0 +1,66 @@
+import type { Message } from "@mariozechner/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 === "toolResult") {
+    return [{
+      kind: "tool_result",
+      name: msg.toolName,
+      text: sanitize(textOf(msg.content)),
+      isError: msg.isError,
+      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 === "thinking") {
+        blocks.push({
+          kind: "thinking",
+          text: sanitize(part.thinking),
+          redacted: part.redacted ?? false,
+          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));
+
+

package/node_modules/@sting8k/pi-vcc/src/core/recall-scope.ts

@@ -0,0 +1,14 @@
+export type RecallScope = "lineage" | "all";
+
+const SCOPE_RE = /\bscope:(lineage|all)\b/i;
+
+export const normalizeRecallScope = (scope?: unknown): RecallScope =>
+  typeof scope === "string" && scope.toLowerCase() === "all" ? "all" : "lineage";
+
+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/node_modules/@sting8k/pi-vcc/src/core/render-entries.ts

@@ -0,0 +1,55 @@
+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 (!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 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}`,
+    };
+  }
+  // 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 }) };
+};
+
+