pi-blackhole 0.4.2 → 0.4.3

package/src/core/format.ts

@@ -17,16 +17,26 @@ const TUI_SAFE_LINE_CHARS = 120;
  */
 function wrapLineWithContinuation(line: string, maxChars: number): string[] {
   const indent = line.match(/^\s*(?:[-*]\s+|\d+\.\s+)?/)?.[0] ?? "";
-  const continuationIndent = indent ? " ".repeat(Math.min(indent.length, 8)) : "";
+  const continuationIndent = indent
+    ? " ".repeat(Math.min(indent.length, 8))
+    : "";
   // Wrap at reduced width so prepending continuationIndent doesn't exceed maxChars
-  const safeMaxChars = continuationIndent ? maxChars - continuationIndent.length : maxChars;
+  const safeMaxChars = continuationIndent
+    ? maxChars - continuationIndent.length
+    : maxChars;
   const wrapped = wrapTextWithAnsi(line, safeMaxChars);
   if (wrapped.length <= 1 || !continuationIndent) return wrapped;
   return [wrapped[0], ...wrapped.slice(1).map((l) => continuationIndent + l)];
 }
 
-export const wrapLongLines = (text: string, maxChars = TUI_SAFE_LINE_CHARS): string =>
-  text.split("\n").flatMap((line) => wrapLineWithContinuation(line, maxChars)).join("\n");
+export const wrapLongLines = (
+  text: string,
+  maxChars = TUI_SAFE_LINE_CHARS,
+): string =>
+  text
+    .split("\n")
+    .flatMap((line) => wrapLineWithContinuation(line, maxChars))
+    .join("\n");
 
 export const capBrief = (text: string): string => {
   const lines = text.split("\n");

package/src/core/lineage.ts

@@ -7,11 +7,15 @@ export interface LineageSessionManagerLike {
   getEntries?: () => LineageEntryLike[];
 }
 
-export const getActiveLineageEntryIds = (sessionManager: LineageSessionManagerLike): Set<string> => {
+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)));
+      return new Set(
+        branch.map((e) => e.id).filter((id): id is string => Boolean(id)),
+      );
     }
   } catch {
     // fall through to defensive fallback
@@ -19,7 +23,9 @@ export const getActiveLineageEntryIds = (sessionManager: LineageSessionManagerLi
 
   try {
     const all = sessionManager.getEntries?.() ?? [];
-    return new Set(all.map((e) => e.id).filter((id): id is string => Boolean(id)));
+    return new Set(
+      all.map((e) => e.id).filter((id): id is string => Boolean(id)),
+    );
   } catch {
     return new Set();
   }

package/src/core/load-messages.ts

@@ -20,7 +20,11 @@ const MAX_CACHE_SIZE = 3;
 const CACHE_TTL_MS = 2_000;
 const cache = new Map<string, CacheEntry>();
 
-function cacheKey(sessionFile: string, full: boolean, allowedEntryIds: Set<string> | undefined): string {
+function cacheKey(
+  sessionFile: string,
+  full: boolean,
+  allowedEntryIds: Set<string> | undefined,
+): string {
   let hash = `${sessionFile}::${full}`;
   if (allowedEntryIds && allowedEntryIds.size > 0) {
     // Include the full set as sorted JSON for collision-free caching
@@ -29,7 +33,11 @@ function cacheKey(sessionFile: string, full: boolean, allowedEntryIds: Set<strin
   return hash;
 }
 
-function getCached(sessionFile: string, full: boolean, allowedEntryIds?: Set<string>): LoadedMessages | undefined {
+function getCached(
+  sessionFile: string,
+  full: boolean,
+  allowedEntryIds?: Set<string>,
+): LoadedMessages | undefined {
   const key = cacheKey(sessionFile, full, allowedEntryIds);
   const entry = cache.get(key);
   if (!entry) return undefined;
@@ -55,7 +63,12 @@ function getCached(sessionFile: string, full: boolean, allowedEntryIds?: Set<str
   return entry.result;
 }
 
-function setCache(sessionFile: string, full: boolean, allowedEntryIds: Set<string> | undefined, result: LoadedMessages): void {
+function setCache(
+  sessionFile: string,
+  full: boolean,
+  allowedEntryIds: Set<string> | undefined,
+  result: LoadedMessages,
+): void {
   // Evict oldest if at capacity
   if (cache.size >= MAX_CACHE_SIZE) {
     const oldest = cache.entries().next();
@@ -85,10 +98,16 @@ export const loadAllMessages = (
   let parseErrors = 0;
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
-    try { entries.push(JSON.parse(line)); } catch { parseErrors++; }
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      parseErrors++;
+    }
   }
   if (parseErrors > 0) {
-    console.warn(`blackhole: ${parseErrors} malformed JSONL line(s) in ${sessionFile}`);
+    console.warn(
+      `blackhole: ${parseErrors} malformed JSONL line(s) in ${sessionFile}`,
+    );
   }
   const rendered: RenderedEntry[] = [];
   const rawMessages: Message[] = [];

package/src/core/normalize.ts

@@ -25,38 +25,64 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
     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: msgIndex,
+          });
         }
       }
     }
-    return blocks.length > 0 ? blocks : [{ kind: "user", text: "", sourceIndex: msgIndex }];
+    return blocks.length > 0
+      ? blocks
+      : [{ kind: "user", text: "", sourceIndex: msgIndex }];
   }
 
   if ((msg as any).role === "bashExecution") {
     const bashMsg = msg as unknown as LocalBashMessage;
-    return [{ kind: "bash", command: bashMsg.command ?? "", output: bashMsg.output ?? "", exitCode: bashMsg.exitCode, sourceIndex: msgIndex }];
+    return [
+      {
+        kind: "bash",
+        command: bashMsg.command ?? "",
+        output: bashMsg.output ?? "",
+        exitCode: bashMsg.exitCode,
+        sourceIndex: msgIndex,
+      },
+    ];
   }
 
   if (msg.role === "toolResult") {
-    return [{
-      kind: "tool_result",
-      name: msg.toolName,
-      text: sanitize(textOf(msg.content)),
-      isError: msg.isError,
-      sourceIndex: msgIndex,
-    }];
+    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 }];
+      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 });
+        blocks.push({
+          kind: "assistant",
+          text: sanitize(part.text),
+          sourceIndex: msgIndex,
+        });
       } else if (part.type === "thinking") {
         blocks.push({
           kind: "thinking",
@@ -81,5 +107,3 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
 
 export const normalize = (messages: Message[]): NormalizedBlock[] =>
   messages.flatMap((msg, i) => normalizeOne(msg, i));
-
-

package/src/core/recall-scope.ts

@@ -7,19 +7,27 @@ const MODE_RE = /\bmode:(hybrid|file|touched)\b/i;
 const VALID_MODES = new Set(["hybrid", "file", "touched"]);
 
 export const normalizeRecallScope = (scope?: unknown): RecallScope =>
-  typeof scope === "string" && scope.toLowerCase() === "all" ? "all" : "lineage";
+  typeof scope === "string" && scope.toLowerCase() === "all"
+    ? "all"
+    : "lineage";
 
 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; mode: RecallMode; text: string } => {
+export const parseRecallScope = (
+  text: string,
+): { scope: RecallScope; mode: RecallMode; text: string } => {
   const scopeMatch = text.match(SCOPE_RE);
   const modeMatch = text.match(MODE_RE);
   return {
     scope: normalizeRecallScope(scopeMatch?.[1]),
     mode: normalizeRecallMode(modeMatch?.[1]),
-    text: text.replace(SCOPE_RE, "").replace(MODE_RE, "").replace(/\s+/g, " ").trim(),
+    text: text
+      .replace(SCOPE_RE, "")
+      .replace(MODE_RE, "")
+      .replace(/\s+/g, " ")
+      .trim(),
   };
 };

package/src/core/render-entries.ts

@@ -34,15 +34,27 @@ const extractFilesFromContent = (content: Message["content"]): string[] => {
     .filter((p): p is string => p !== null);
 };
 
-export const renderMessage = (msg: Message, index: number, id: string, full = false): RenderedEntry => {
+export const renderMessage = (
+  msg: Message,
+  index: number,
+  id: string,
+  full = false,
+): RenderedEntry => {
   if (msg.role === "user") {
-    return { index, id, role: "user", summary: full ? textOf(msg.content) : clip(textOf(msg.content), 300) };
+    return {
+      index,
+      id,
+      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, id, role: "tool_result",
+      index,
+      id,
+      role: "tool_result",
       summary: `${prefix}[${msg.toolName}] ${text}`,
     };
   }
@@ -58,7 +70,11 @@ export const renderMessage = (msg: Message, index: number, id: string, full = fa
   const tools = toolCalls(msg.content);
   const files = extractFilesFromContent(msg.content);
   const summary = tools ? `${tools}\n${text}` : text;
-  return { index, id, role: "assistant", summary, ...(files.length > 0 && { files }) };
+  return {
+    index,
+    id,
+    role: "assistant",
+    summary,
+    ...(files.length > 0 && { files }),
+  };
 };
-
-

package/src/core/sanitize.ts

@@ -2,4 +2,8 @@ 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, "");
+  text
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .replace(ANSI_RE, "")
+    .replace(CTRL_RE, "");

package/src/core/search-entries.ts

@@ -81,21 +81,100 @@ const snippetRegex = (terms: string[]): RegExp => {
 // ── Stopwords for natural language queries ──
 const STOPWORDS = new Set([
   // English
-  "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
-  "have", "has", "had", "do", "does", "did", "will", "would", "could",
-  "should", "may", "might", "can", "shall", "of", "in", "to", "for",
-  "with", "on", "at", "from", "by", "as", "into", "through", "during",
-  "before", "after", "above", "below", "between", "out", "off", "over",
-  "under", "again", "further", "then", "once", "here", "there", "when",
-  "where", "why", "how", "all", "both", "each", "few", "more", "most",
-  "other", "some", "such", "no", "nor", "not", "only", "own", "same",
-  "so", "than", "too", "very", "just", "about", "it", "its", "that",
-  "this", "what", "which", "who", "whom", "these", "those",
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "can",
+  "shall",
+  "of",
+  "in",
+  "to",
+  "for",
+  "with",
+  "on",
+  "at",
+  "from",
+  "by",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "both",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "about",
+  "it",
+  "its",
+  "that",
+  "this",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "these",
+  "those",
 ]);
 
 /** Remove stopwords, keep meaningful terms. */
 const filterStopwords = (terms: string[]): string[] => {
-  const meaningful = terms.filter((t) => !STOPWORDS.has(t.toLowerCase()) && t.length > 1);
+  const meaningful = terms.filter(
+    (t) => !STOPWORDS.has(t.toLowerCase()) && t.length > 1,
+  );
   // If all terms were stopwords, return original (don't lose everything)
   return meaningful.length > 0 ? meaningful : terms;
 };
@@ -120,8 +199,8 @@ const termFreq = (text: string, pattern: RegExp): number => {
 };
 
 interface BM25Context {
-  n: number;         // total docs
-  avgDl: number;     // average doc length (words)
+  n: number; // total docs
+  avgDl: number; // average doc length (words)
   df: Map<string, number>; // term -> number of docs containing it
 }
 
@@ -156,7 +235,9 @@ const bm25Score = (doc: string, terms: string[], ctx: BM25Context): number => {
     // IDF: log((N - df + 0.5) / (df + 0.5) + 1)
     const idf = Math.log((ctx.n - docFreq + 0.5) / (docFreq + 0.5) + 1);
     // TF saturation with length normalization
-    const tfNorm = (tf * (BM25_K + 1)) / (tf + BM25_K * (1 - BM25_B + BM25_B * dl / ctx.avgDl));
+    const tfNorm =
+      (tf * (BM25_K + 1)) /
+      (tf + BM25_K * (1 - BM25_B + (BM25_B * dl) / ctx.avgDl));
     score += idf * tfNorm;
   }
 
@@ -164,7 +245,11 @@ const bm25Score = (doc: string, terms: string[], ctx: BM25Context): number => {
 };
 
 /** Line-based snippet: ±contextLines around first regex match. */
-const lineSnippet = (text: string, regex: RegExp, contextLines = 2): string | undefined => {
+const lineSnippet = (
+  text: string,
+  regex: RegExp,
+  contextLines = 2,
+): string | undefined => {
   const lines = text.split("\n");
   let matchIdx = -1;
   for (let i = 0; i < lines.length; i++) {
@@ -216,8 +301,10 @@ function extractToolCallText(args: Record<string, unknown>): string {
       }
     }
   }
-  if (typeof args.oldText === "string" && !Array.isArray(args.edits)) text += args.oldText + "\n";
-  if (typeof args.newText === "string" && !Array.isArray(args.edits)) text += args.newText + "\n";
+  if (typeof args.oldText === "string" && !Array.isArray(args.edits))
+    text += args.oldText + "\n";
+  if (typeof args.newText === "string" && !Array.isArray(args.edits))
+    text += args.newText + "\n";
   return text;
 }
 
@@ -247,12 +334,17 @@ export function getFileIndicators(msg: Message): FileMatch[] {
   return fileMatches;
 }
 
-function computeFileMatches(msg: Message | undefined, query: string): FileMatch[] {
+function computeFileMatches(
+  msg: Message | undefined,
+  query: string,
+): FileMatch[] {
   if (!msg?.content || typeof msg.content === "string") return [];
   const rawQuery = query.trim();
   const hasQuery = rawQuery.length > 0;
   if (!hasQuery) return getFileIndicators(msg as Message);
-  const regex = looksLikeRegex(rawQuery) ? safeRegex(rawQuery) : snippetRegex(rawQuery.split(/\s+/));
+  const regex = looksLikeRegex(rawQuery)
+    ? safeRegex(rawQuery)
+    : snippetRegex(rawQuery.split(/\s+/));
   const fileMatches: FileMatch[] = [];
 
   for (const part of msg.content) {

package/src/core/settings.ts

@@ -6,7 +6,5 @@
 import { scaffoldConfig } from "./unified-config.js";
 
 export function scaffoldSettings(): void {
-	scaffoldConfig();
+  scaffoldConfig();
 }
-
-

package/src/core/summarize.ts

@@ -17,7 +17,13 @@ export interface CompileInput {
   fileOps?: FileOps;
 }
 
-const HEADER_NAMES = ["Session Goal", "Files And Changes", "Commits", "Outstanding Context", "User Preferences"];
+const HEADER_NAMES = [
+  "Session Goal",
+  "Files And Changes",
+  "Commits",
+  "Outstanding Context",
+  "User Preferences",
+];
 
 const SEPARATOR = "\n\n---\n\n";
 
@@ -28,8 +34,7 @@ const sectionOf = (text: string, header: string): string => {
   if (start < 0) return "";
   const after = text.slice(start);
   // Find next section header (must start at line boundary to avoid matching in content)
-  const nextSection = HEADER_NAMES
-    .filter((h) => h !== header)
+  const nextSection = HEADER_NAMES.filter((h) => h !== header)
     .map((h) => {
       // Escape the header name for regex safety
       const escaped = h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -41,7 +46,9 @@ const sectionOf = (text: string, header: string): string => {
     })
     .filter((n) => n >= 0);
   const nextSep = after.indexOf("\n\n---\n\n");
-  const candidates = [...nextSection, ...(nextSep > 0 ? [nextSep] : [])].sort((a, b) => a - b);
+  const candidates = [...nextSection, ...(nextSep > 0 ? [nextSep] : [])].sort(
+    (a, b) => a - b,
+  );
   const end = candidates[0];
   return (end ? after.slice(0, end) : after).trim();
 };
@@ -54,7 +61,11 @@ const briefOf = (text: string): string => {
 };
 
 /** Merge a header section */
-const mergeHeaderSection = (header: string, prev: string, fresh: string): string => {
+const mergeHeaderSection = (
+  header: string,
+  prev: string,
+  fresh: string,
+): string => {
   // Outstanding Context is volatile -- always use fresh only
   if (header === "Outstanding Context") return fresh;
   if (!prev) return fresh;
@@ -66,16 +77,20 @@ const mergeHeaderSection = (header: string, prev: string, fresh: string): string
   }
 
   // Session Goal, User Preferences: line-level dedup, cap
-  const isClean = (l: string) => l.startsWith("- ") && !l.includes("<skill") && !l.includes("</skill");
+  const isClean = (l: string) =>
+    l.startsWith("- ") && !l.includes("<skill") && !l.includes("</skill");
   const prevLines = prev.split("\n").filter(isClean);
   const freshLines = fresh.split("\n").filter(isClean);
   const combined = [...new Set([...prevLines, ...freshLines])];
   const CAP = header === "Session Goal" ? 8 : header === "Commits" ? 8 : 15;
   // Session Goal: keep first items so the original first message persists
   // Other sections: keep last items (fresh overrides stale)
-  const capped = combined.length > CAP
-    ? (header === "Session Goal" ? combined.slice(0, CAP) : combined.slice(-CAP))
-    : combined;
+  const capped =
+    combined.length > CAP
+      ? header === "Session Goal"
+        ? combined.slice(0, CAP)
+        : combined.slice(-CAP)
+      : combined;
   if (capped.length === 0) return "";
   return `[${header}]\n${capped.join("\n")}`;
 };
@@ -115,8 +130,10 @@ const mergeFileLines = (prev: string, fresh: string): string => {
   };
 
   const lines: string[] = [];
-  if (merged.Modified.size > 0) lines.push(`- Modified: ${cap(merged.Modified, 10)}`);
-  if (merged.Created.size > 0) lines.push(`- Created: ${cap(merged.Created, 10)}`);
+  if (merged.Modified.size > 0)
+    lines.push(`- Modified: ${cap(merged.Modified, 10)}`);
+  if (merged.Created.size > 0)
+    lines.push(`- Created: ${cap(merged.Created, 10)}`);
   if (merged.Read.size > 0) lines.push(`- Read: ${cap(merged.Read, 10)}`);
   if (lines.length === 0) return "";
   return `[Files And Changes]\n${lines.join("\n")}`;
@@ -130,13 +147,11 @@ const mergeBriefTranscript = (prev: string, fresh: string): string => {
 
 const mergePrevious = (prev: string, fresh: string): string => {
   // Merge header sections
-  const headers = HEADER_NAMES
-    .map((header) => {
-      const freshSec = sectionOf(fresh, header);
-      const prevSec = sectionOf(prev, header);
-      return mergeHeaderSection(header, prevSec, freshSec);
-    })
-    .filter(Boolean);
+  const headers = HEADER_NAMES.map((header) => {
+    const freshSec = sectionOf(fresh, header);
+    const prevSec = sectionOf(prev, header);
+    return mergeHeaderSection(header, prevSec, freshSec);
+  }).filter(Boolean);
 
   // Merge brief transcript
   const prevBrief = briefOf(prev);
@@ -189,7 +204,9 @@ export const compile = (input: CompileInput): string => {
  */
 const stripRecallNotes = (text: string): string => {
   const paragraphs = text.split(/\n\n+/);
-  const kept = paragraphs.filter((p) => !p.includes("The conversation before this point has been compacted"));
+  const kept = paragraphs.filter(
+    (p) => !p.includes("The conversation before this point has been compacted"),
+  );
   return kept.join("\n\n");
 };
 
@@ -204,12 +221,16 @@ const stripOMContent = (text: string): string => {
   const obsIdx = obsMatch ? obsMatch.index! : -1;
 
   // Also detect the basic recall-guidance footer (no observation preamble)
-  const basicFooterIdx = text.indexOf("Use `recall` with an id to retrieve original context, or `#N:path` drill-down");
+  const basicFooterIdx = text.indexOf(
+    "Use `recall` with an id to retrieve original context, or `#N:path` drill-down",
+  );
 
   // Find the start of OM content: either the instructions preamble or the first section header
   let stripFrom = -1;
   if (reflIdx >= 0 || obsIdx >= 0) {
-    const preambleIdx = text.indexOf("These are condensed memories from earlier in this session.");
+    const preambleIdx = text.indexOf(
+      "These are condensed memories from earlier in this session.",
+    );
     const minSectionIdx = Math.min(
       reflIdx >= 0 ? reflIdx : Infinity,
       obsIdx >= 0 ? obsIdx : Infinity,