supipowers 1.5.3 → 2.0.0

package/src/context-mode/compressor.ts

@@ -1,4 +1,9 @@
 // src/context-mode/compressor.ts
+import { canonicalToolName } from "./tool-name.js";
+import type { ContextModeProcessorsConfig } from "../types.js";
+import type { ProcessorKey } from "./metrics-store.js";
+import { processorKeyForTool } from "./processor-keys.js";
+import { lookupProcessor } from "./processors/registry.js";
 
 interface ToolResultEventLike {
   toolName: string;
@@ -12,13 +17,53 @@ interface ToolResultEventResult {
   content?: Array<{ type: string; text: string }>;
 }
 
+export interface RunEmissionPipelineOptions {
+  processors?: ContextModeProcessorsConfig;
+}
+
+export interface PipelineResult {
+  result: ToolResultEventResult | undefined;
+  processorKey: ProcessorKey;
+}
+
 const BASH_HEAD_LINES = 5;
 const BASH_TAIL_LINES = 10;
 const READ_HEAD_LINES = 80;
 const READ_TAIL_LINES = 30;
-const GREP_MAX_MATCHES = 10;
+const SEARCH_MAX_MATCHES = 10;
 const FIND_MAX_PATHS = 20;
 
+
+const READ_PATH_SELECTOR_RE = /:(?:raw|\d+(?:[-+]\d+)?|L\d+(?:-L?\d+|\+L?\d+)?)$/i;
+
+function getReadPath(input: Record<string, unknown>): string | null {
+  const path = input.path ?? input.file_path;
+  return typeof path === "string" && path.length > 0 ? path : null;
+}
+
+function hasEmbeddedReadSelector(input: Record<string, unknown>): boolean {
+  const path = getReadPath(input);
+  return path != null && READ_PATH_SELECTOR_RE.test(path);
+}
+
+function formatReadSelectorHint(input: Record<string, unknown>, start: number, end: number): string {
+  const path = getReadPath(input);
+  const selector = path?.startsWith("http://") || path?.startsWith("https://")
+    ? `L${start}-L${end}`
+    : `${start}-${end}`;
+  return path
+    ? `read(path="${path}:${selector}")`
+    : `read(path="<path>:${selector}")`;
+}
+/**
+ * OMP's `shellMinimizer` already shrinks bash output and appends this footer
+ * pointing at the full bytes. When we see it, supipowers must NOT re-compress —
+ * doing so would either drop the pointer or double-truncate already-trimmed text.
+ * The artifact id is recoverable via `read artifact://<id>`.
+ */
+export const OMP_MINIMIZER_FOOTER_RE = /(?:^|\n)\[raw output: artifact:\/\/[a-zA-Z0-9_-]+\]\s*$/;
+
+
 /** Measure total byte length of text content entries */
 function measureTextBytes(content: Array<{ type: string; text?: string }>): number {
   let total = 0;
@@ -43,6 +88,22 @@ function getCombinedText(content: Array<{ type: string; text?: string }>): strin
     .join("\n");
 }
 
+function exitCodeFromDetails(details: unknown): number | null {
+  if (details && typeof details === "object" && "exitCode" in details) {
+    const exitCode = (details as { exitCode?: unknown }).exitCode;
+    return typeof exitCode === "number" ? exitCode : null;
+  }
+  return null;
+}
+
+function eolOf(text: string): "\n" | "\r\n" {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+
+function wrapText(text: string): ToolResultEventResult {
+  return { content: [{ type: "text", text }] };
+}
+
 /** Compress bash tool output */
 function compressBash(text: string, details: unknown): string | undefined {
   const exitCode =
@@ -50,6 +111,9 @@ function compressBash(text: string, details: unknown): string | undefined {
       ? (details as { exitCode: number }).exitCode
       : 0;
 
+  // Already minimized by OMP — pass through to preserve the artifact pointer.
+  if (OMP_MINIMIZER_FOOTER_RE.test(text)) return undefined;
+
   // Non-zero exit: keep full output for debugging
   if (exitCode !== 0) return undefined;
 
@@ -71,8 +135,11 @@ function compressBash(text: string, details: unknown): string | undefined {
 
 /** Compress read tool output — head+tail with hashline preservation */
 function compressRead(text: string, input: Record<string, unknown>): string | undefined {
-  // Scoped reads (offset/limit/sel) are already targeted — pass through
-  if (input.offset != null || input.limit != null || input.sel != null) return undefined;
+  // Already minimized by OMP (e.g. when reading a `bash-original` artifact back). Pass through.
+  if (OMP_MINIMIZER_FOOTER_RE.test(text)) return undefined;
+
+  // Scoped reads (offset/limit/path selector) are already targeted — pass through
+  if (input.offset != null || input.limit != null || hasEmbeddedReadSelector(input)) return undefined;
 
   const lines = text.split("\n");
   const totalLines = lines.length;
@@ -84,26 +151,27 @@ function compressRead(text: string, input: Record<string, unknown>): string | un
   const omittedStart = READ_HEAD_LINES + 1;
   const omittedEnd = totalLines - READ_TAIL_LINES;
 
+  const selectorHint = formatReadSelectorHint(input, omittedStart, omittedEnd);
   return [
     ...head,
-    `[...${omittedEnd - omittedStart + 1} lines omitted. Use read(path, sel="L${omittedStart}-L${omittedEnd}") to view...]`,
+    `[...${omittedEnd - omittedStart + 1} lines omitted. Use ${selectorHint} to view...]`,
     ...tail,
   ].join("\n");
 }
 
-/** Compress grep tool output */
-function compressGrep(text: string): string | undefined {
+/** Compress search tool output */
+function compressSearch(text: string): string | undefined {
   const lines = text.split("\n").filter((l) => l.length > 0);
   const totalMatches = lines.length;
 
-  if (totalMatches <= GREP_MAX_MATCHES) return undefined;
+  if (totalMatches <= SEARCH_MAX_MATCHES) return undefined;
 
-  const kept = lines.slice(0, GREP_MAX_MATCHES);
+  const kept = lines.slice(0, SEARCH_MAX_MATCHES);
   return [
-    `${totalMatches} matches total, showing first ${GREP_MAX_MATCHES}:`,
+    `${totalMatches} matches total, showing first ${SEARCH_MAX_MATCHES}:`,
     "",
     ...kept,
-    `[...compressed: ${totalMatches - GREP_MAX_MATCHES} more matches omitted...]`,
+    `[...compressed: ${totalMatches - SEARCH_MAX_MATCHES} more matches omitted...]`,
   ].join("\n");
 }
 
@@ -123,45 +191,82 @@ function compressFind(text: string): string | undefined {
   ].join("\n");
 }
 
-/** Compress a tool result if it exceeds the threshold */
-export function compressToolResult(
+/** Run the deterministic emission pipeline and report the processor decision. */
+export function runEmissionPipeline(
   event: ToolResultEventLike,
   threshold: number,
-): ToolResultEventResult | undefined {
-  // General rules: pass through errors, non-text content, and small outputs
-  if (event.isError) return undefined;
-  if (hasNonTextContent(event.content)) return undefined;
-  if (measureTextBytes(event.content) <= threshold) return undefined;
+  options: RunEmissionPipelineOptions = {},
+): PipelineResult {
+  const canonicalTool = canonicalToolName(event.toolName);
+  const nativeProcessorKey = processorKeyForTool(canonicalTool);
+  const passthroughProcessorKey: ProcessorKey = nativeProcessorKey === null ? null : "passthrough";
+
+  // General rules: pass through errors, non-text content, and small outputs.
+  if (event.isError) return { result: undefined, processorKey: passthroughProcessorKey };
+  if (hasNonTextContent(event.content)) return { result: undefined, processorKey: passthroughProcessorKey };
+
+  const byteSize = measureTextBytes(event.content);
+  if (byteSize <= threshold) {
+    return {
+      result: undefined,
+      processorKey: passthroughProcessorKey,
+    };
+  }
 
   const text = getCombinedText(event.content);
-  let compressed: string | undefined;
 
-  switch (event.toolName) {
+  if (canonicalTool === "bash" && OMP_MINIMIZER_FOOTER_RE.test(text)) {
+    return { result: undefined, processorKey: "omp-minimizer" };
+  }
+
+  if (canonicalTool === "bash") {
+    const match = lookupProcessor(canonicalTool, event.input, text, options);
+    if (match) {
+      const output = match.processor(text, {
+        exitCode: exitCodeFromDetails(event.details),
+        eol: eolOf(text),
+      });
+      if (!output.passthrough) {
+        return { result: wrapText(output.text), processorKey: output.processorKey };
+      }
+    }
+  }
+
+  let compressed: string | undefined;
+  switch (canonicalTool) {
     case "bash":
       compressed = compressBash(text, event.details);
       break;
     case "read":
       compressed = compressRead(text, event.input);
       break;
-    case "grep":
-      compressed = compressGrep(text);
+    case "search":
+      compressed = compressSearch(text);
       break;
     case "find":
       compressed = compressFind(text);
       break;
     default:
-      return undefined;
+      return { result: undefined, processorKey: null };
   }
 
-  if (!compressed) return undefined;
-  return { content: [{ type: "text", text: compressed }] };
+  if (!compressed) return { result: undefined, processorKey: "passthrough" };
+  return { result: wrapText(compressed), processorKey: nativeProcessorKey };
+}
+
+/** Compress a tool result if it exceeds the threshold */
+export function compressToolResult(
+  event: ToolResultEventLike,
+  threshold: number,
+): ToolResultEventResult | undefined {
+  return runEmissionPipeline(event, threshold).result;
 }
 
 /** Summarization prompt templates by tool type */
 const SUMMARIZE_PROMPTS: Record<string, string> = {
   bash: "Summarize this command output. Preserve: exit code, key findings, error messages, file paths mentioned. Be concise (under 200 words).",
   read: "Summarize this file content. Preserve: file structure, key exports/functions, notable patterns. Be concise (under 200 words).",
-  grep: "Summarize these search results. Preserve: match count, most relevant matches, file distribution. Be concise (under 200 words).",
+  search: "Summarize these search results. Preserve: match count, most relevant matches, file distribution. Be concise (under 200 words).",
   find: "Summarize these file paths. Preserve: directory structure, file count, key patterns. Be concise (under 200 words).",
 };
 
@@ -187,7 +292,7 @@ export async function compressToolResultWithLLM(
 
   // Above LLM threshold: try LLM summarization
   try {
-    const prompt = SUMMARIZE_PROMPTS[event.toolName] ?? "Summarize this output concisely (under 200 words).";
+    const prompt = SUMMARIZE_PROMPTS[canonicalToolName(event.toolName)] ?? "Summarize this output concisely (under 200 words).";
     const summary = await summarize(`${prompt}\n\n${text}`, event.toolName);
 
     // Validate: non-empty and reasonably sized

package/src/context-mode/dedup.ts

@@ -0,0 +1,108 @@
+import { createHash } from "node:crypto";
+import type { ProcessorKey } from "./metrics-store.js";
+
+export interface DedupRecord {
+  contentHash: string;
+  turnId: number;
+  bytes: number;
+  tsMonotonic: number;
+}
+
+export interface DedupState {
+  records: Map<string, DedupRecord>;
+  turnCounter: number;
+}
+
+interface ToolResultEventResult {
+  content?: Array<{ type: string; text: string }>;
+}
+
+export interface DedupSubstitutionInput {
+  result: ToolResultEventResult | undefined;
+  processorKey: ProcessorKey;
+  sourceHash: string | null;
+  dedupState: DedupState;
+  processedBytes: number;
+}
+
+export interface DedupSubstitutionResult {
+  result: ToolResultEventResult | undefined;
+  processorKey: ProcessorKey;
+}
+
+export const TTL_TURNS = 10;
+
+export function createDedupState(): DedupState {
+  return { records: new Map(), turnCounter: 0 };
+}
+
+export function combinedTextOf(
+  content: Array<{ type: string; text?: string }> | undefined,
+): string {
+  if (!content) return "";
+  const textEntries: string[] = [];
+  for (const entry of content) {
+    if (entry.type === "text" && entry.text) {
+      textEntries.push(entry.text);
+    }
+  }
+  return textEntries.join("\n");
+}
+
+function contentHashFor(result: ToolResultEventResult): string {
+  return createHash("sha256").update(combinedTextOf(result.content)).digest("hex");
+}
+
+export function maybeSubstitute(input: DedupSubstitutionInput): DedupSubstitutionResult {
+  const { result, processorKey, sourceHash, dedupState, processedBytes } = input;
+  if (sourceHash === null || result === undefined) {
+    return { result, processorKey };
+  }
+
+  const key = sourceHash;
+  const contentHash = contentHashFor(result);
+  const existing = dedupState.records.get(key);
+  if (!existing || existing.contentHash !== contentHash) {
+    const supersedes = existing && existing.contentHash !== contentHash ? existing : null;
+    dedupState.turnCounter += 1;
+    dedupState.records.set(key, {
+      contentHash,
+      turnId: dedupState.turnCounter,
+      bytes: processedBytes,
+      tsMonotonic: dedupState.turnCounter,
+    });
+    if (supersedes) {
+      const annotated = withSupersedesAnnotation(result, supersedes);
+      return { result: annotated, processorKey };
+    }
+    return { result, processorKey };
+  }
+
+  if (dedupState.turnCounter - existing.tsMonotonic >= TTL_TURNS) {
+    dedupState.turnCounter += 1;
+    dedupState.records.set(key, {
+      contentHash,
+      turnId: dedupState.turnCounter,
+      bytes: processedBytes,
+      tsMonotonic: dedupState.turnCounter,
+    });
+    return { result, processorKey };
+  }
+
+  const placeholderText = `[…dedup: same as turn ${existing.turnId} (${existing.bytes} B); processor=${processorKey}]`;
+  return {
+    result: { content: [{ type: "text", text: placeholderText }] },
+    processorKey: "dedup",
+  };
+}
+
+function withSupersedesAnnotation(
+  result: ToolResultEventResult,
+  prior: DedupRecord,
+): ToolResultEventResult {
+  const banner = `[\u2026 supersedes turn ${prior.turnId} (was ${prior.bytes} B); old bytes remain in transcript history]`;
+  const text = combinedTextOf(result.content);
+  return {
+    content: [{ type: "text", text: text.length > 0 ? `${banner}\n${text}` : banner }],
+  };
+}

package/src/context-mode/detector.ts

@@ -10,15 +10,41 @@ export interface ContextModeStatus {
     ctxIndex: boolean;
     ctxSearch: boolean;
     ctxFetchAndIndex: boolean;
+    ctxOpenCached: boolean;
+    ctxStats: boolean;
+    ctxPurge: boolean;
+    ctxRepomap: boolean;
+    ctxSymbol: boolean;
   };
 }
 
 /**
- * Context-mode tools are native (registered by this extension), so they are
- * always available when the extension is loaded. The interface is preserved for
- * backward compatibility with hooks/routing consumers.
+ * Return active context-mode tool status. When activeTools is supplied, it is
+ * treated as the current model-visible tool set. Without it, keep the legacy
+ * registered-tool fallback for compatibility with older call sites.
  */
-export function detectContextMode(_activeTools?: string[]): ContextModeStatus {
+export function detectContextMode(activeTools?: string[]): ContextModeStatus {
+  if (activeTools) {
+    const active = new Set(activeTools);
+    const tools = {
+      ctxExecute: active.has("ctx_execute"),
+      ctxBatchExecute: active.has("ctx_batch_execute"),
+      ctxExecuteFile: active.has("ctx_execute_file"),
+      ctxIndex: active.has("ctx_index"),
+      ctxSearch: active.has("ctx_search"),
+      ctxFetchAndIndex: active.has("ctx_fetch_and_index"),
+      ctxOpenCached: active.has("ctx_open_cached"),
+      ctxStats: active.has("ctx_stats"),
+      ctxPurge: active.has("ctx_purge"),
+      ctxRepomap: active.has("ctx_repomap"),
+      ctxSymbol: active.has("ctx_symbol"),
+    };
+    return {
+      available: Object.values(tools).some(Boolean),
+      tools,
+    };
+  }
+
   return {
     available: true,
     tools: {
@@ -28,6 +54,11 @@ export function detectContextMode(_activeTools?: string[]): ContextModeStatus {
       ctxIndex: true,
       ctxSearch: true,
       ctxFetchAndIndex: true,
+      ctxOpenCached: true,
+      ctxStats: true,
+      ctxPurge: true,
+      ctxRepomap: true,
+      ctxSymbol: true,
     },
   };
 }

package/src/context-mode/event-extractor.ts

@@ -1,6 +1,7 @@
 // src/context-mode/event-extractor.ts
 import { PRIORITY } from "./event-store.js";
 import type { EventCategory, EventPriority, TrackedEvent } from "./event-store.js";
+import { canonicalToolName } from "./tool-name.js";
 
 type Event = Omit<TrackedEvent, "id" | "dataHash">;
 
@@ -53,6 +54,7 @@ export function extractEvents(
     details: unknown;
   },
   sessionId: string,
+  sourceHash?: string | null,
 ): Event[] {
   const events: Event[] = [];
   const text = getTextContent(event.content);
@@ -65,7 +67,7 @@ export function extractEvents(
     }, PRIORITY.critical, "tool_result"));
   }
 
-  switch (event.toolName) {
+  switch (canonicalToolName(event.toolName)) {
     case "bash":
       extractBash(events, event, sessionId, text);
       break;
@@ -77,21 +79,20 @@ export function extractEvents(
       if (readPath.includes("/skills/")) {
         events.push(makeEvent(sessionId, "skill", { path: readPath }, PRIORITY.medium, "tool_result"));
       }
-      extractFile(events, event, sessionId, "read");
+      extractFile(events, event, sessionId, "read", PRIORITY.medium, sourceHash);
       break;
     }
     case "edit":
-      extractFile(events, event, sessionId, "edit", PRIORITY.high);
+      extractFile(events, event, sessionId, "edit", PRIORITY.high, sourceHash);
       break;
     case "write":
-      extractFile(events, event, sessionId, "write", PRIORITY.high);
-      break;
-    case "grep":
-      extractFile(events, event, sessionId, "search");
-      break;
-    case "find":
-      extractFile(events, event, sessionId, "find");
+      extractFile(events, event, sessionId, "write", PRIORITY.high, sourceHash);
       break;
+    // `search` and `find` are intentionally not extracted: their `path`
+    // input is usually a directory or a glob, not a real file the caller
+    // touched. The downstream snapshot builder only consumes
+    // `op === "edit"|"write"|"read"` file events, so emitting here would
+    // (a) be silently dropped and (b) waste the 200-event read window.
     case "todo_write":
       events.push(makeEvent(sessionId, "task", {
         input: event.input,
@@ -102,7 +103,7 @@ export function extractEvents(
         events.push(makeEvent(sessionId, "mcp", {
           tool: event.toolName,
         }, PRIORITY.low, "tool_result"));
-      } else if (event.toolName === "task" || event.toolName === "sub_agent") {
+      } else if (canonicalToolName(event.toolName) === "task" || event.toolName === "sub_agent") {
         events.push(makeEvent(sessionId, "subagent", {
           toolName: event.toolName,
           input: event.input,
@@ -171,9 +172,10 @@ function extractFile(
   sessionId: string,
   op: string,
   priority: EventPriority = PRIORITY.medium,
+  sourceHash?: string | null,
 ): void {
   const path = typeof event.input.path === "string" ? event.input.path : "unknown";
-  events.push(makeEvent(sessionId, "file", { op, path }, priority, "tool_result"));
+  events.push(makeEvent(sessionId, "file", { op, path, ...(sourceHash ? { sourceHash } : {}) }, priority, "tool_result"));
 }
 
 /** Extract events from a user prompt (called from before_agent_start handler) */