supipowers 0.4.0 → 0.6.0

package/src/context-mode/compressor.ts

@@ -0,0 +1,200 @@
+// src/context-mode/compressor.ts
+
+interface ToolResultEventLike {
+  toolName: string;
+  input: Record<string, unknown>;
+  content: Array<{ type: string; text?: string }>;
+  isError: boolean;
+  details: unknown;
+}
+
+interface ToolResultEventResult {
+  content?: Array<{ type: string; text: string }>;
+}
+
+const BASH_HEAD_LINES = 5;
+const BASH_TAIL_LINES = 10;
+const READ_PREVIEW_LINES = 10;
+const GREP_MAX_MATCHES = 10;
+const FIND_MAX_PATHS = 20;
+
+/** Measure total byte length of text content entries */
+function measureTextBytes(content: Array<{ type: string; text?: string }>): number {
+  let total = 0;
+  for (const entry of content) {
+    if (entry.type === "text" && entry.text) {
+      total += new TextEncoder().encode(entry.text).byteLength;
+    }
+  }
+  return total;
+}
+
+/** Check if content contains any non-text entries */
+function hasNonTextContent(content: Array<{ type: string }>): boolean {
+  return content.some((entry) => entry.type !== "text");
+}
+
+/** Get combined text from all text content entries */
+function getCombinedText(content: Array<{ type: string; text?: string }>): string {
+  return content
+    .filter((entry) => entry.type === "text" && entry.text)
+    .map((entry) => entry.text!)
+    .join("\n");
+}
+
+/** Compress bash tool output */
+function compressBash(text: string, details: unknown): string | undefined {
+  const exitCode =
+    details && typeof details === "object" && "exitCode" in details
+      ? (details as { exitCode: number }).exitCode
+      : 0;
+
+  // Non-zero exit: keep full output for debugging
+  if (exitCode !== 0) return undefined;
+
+  const lines = text.split("\n");
+  const totalLines = lines.length;
+
+  if (totalLines <= BASH_HEAD_LINES + BASH_TAIL_LINES) return undefined;
+
+  const head = lines.slice(0, BASH_HEAD_LINES);
+  const tail = lines.slice(-BASH_TAIL_LINES);
+  const omitted = totalLines - BASH_HEAD_LINES - BASH_TAIL_LINES;
+
+  return [
+    ...head,
+    `[...compressed: ${omitted} lines omitted (${totalLines} lines total)...]`,
+    ...tail,
+  ].join("\n");
+}
+
+/** Compress read tool output */
+function compressRead(text: string, input: Record<string, unknown>): string | undefined {
+  // Scoped reads (offset/limit) are already targeted — pass through
+  if (input.offset !== undefined || input.limit !== undefined) return undefined;
+
+  const lines = text.split("\n");
+  const totalLines = lines.length;
+  const path = typeof input.path === "string" ? input.path : "unknown";
+
+  if (totalLines <= READ_PREVIEW_LINES) return undefined;
+
+  const preview = lines.slice(0, READ_PREVIEW_LINES);
+  return [
+    `File: ${path} (${totalLines} lines total)`,
+    "",
+    ...preview,
+    `[...compressed: remaining ${totalLines - READ_PREVIEW_LINES} lines omitted...]`,
+  ].join("\n");
+}
+
+/** Compress grep tool output */
+function compressGrep(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;
+
+  const kept = lines.slice(0, GREP_MAX_MATCHES);
+  return [
+    `${totalMatches} matches total, showing first ${GREP_MAX_MATCHES}:`,
+    "",
+    ...kept,
+    `[...compressed: ${totalMatches - GREP_MAX_MATCHES} more matches omitted...]`,
+  ].join("\n");
+}
+
+/** Compress find tool output */
+function compressFind(text: string): string | undefined {
+  const lines = text.split("\n").filter((l) => l.length > 0);
+  const totalFiles = lines.length;
+
+  if (totalFiles <= FIND_MAX_PATHS) return undefined;
+
+  const kept = lines.slice(0, FIND_MAX_PATHS);
+  return [
+    `${totalFiles} files found, showing first ${FIND_MAX_PATHS}:`,
+    "",
+    ...kept,
+    `[...compressed: ${totalFiles - FIND_MAX_PATHS} more files omitted...]`,
+  ].join("\n");
+}
+
+/** Compress a tool result if it exceeds the threshold */
+export function compressToolResult(
+  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;
+
+  const text = getCombinedText(event.content);
+  let compressed: string | undefined;
+
+  switch (event.toolName) {
+    case "bash":
+      compressed = compressBash(text, event.details);
+      break;
+    case "read":
+      compressed = compressRead(text, event.input);
+      break;
+    case "grep":
+      compressed = compressGrep(text);
+      break;
+    case "find":
+      compressed = compressFind(text);
+      break;
+    default:
+      return undefined;
+  }
+
+  if (!compressed) return undefined;
+  return { content: [{ type: "text", text: compressed }] };
+}
+
+/** 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).",
+  find: "Summarize these file paths. Preserve: directory structure, file count, key patterns. Be concise (under 200 words).",
+};
+
+/** Compress with optional LLM summarization for very large outputs */
+export async function compressToolResultWithLLM(
+  event: ToolResultEventLike,
+  threshold: number,
+  llmThreshold: number,
+  summarize: (text: string, toolName: string) => Promise<string>,
+): Promise<ToolResultEventResult | undefined> {
+  // General rules
+  if (event.isError) return undefined;
+  if (hasNonTextContent(event.content)) return undefined;
+  const byteSize = measureTextBytes(event.content);
+  if (byteSize <= threshold) return undefined;
+
+  const text = getCombinedText(event.content);
+
+  // Below LLM threshold: use structural compression
+  if (byteSize < llmThreshold) {
+    return compressToolResult(event, threshold);
+  }
+
+  // Above LLM threshold: try LLM summarization
+  try {
+    const prompt = SUMMARIZE_PROMPTS[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
+    if (summary && summary.length >= 50) {
+      return { content: [{ type: "text", text: summary }] };
+    }
+  } catch {
+    // Fall through to structural compression
+  }
+
+  // Fallback
+  return compressToolResult(event, threshold);
+}

package/src/context-mode/detector.ts

@@ -0,0 +1,43 @@
+// src/context-mode/detector.ts
+
+/** Which context-mode MCP tools are available in the current session */
+export interface ContextModeStatus {
+  available: boolean;
+  tools: {
+    ctxExecute: boolean;
+    ctxBatchExecute: boolean;
+    ctxExecuteFile: boolean;
+    ctxIndex: boolean;
+    ctxSearch: boolean;
+    ctxFetchAndIndex: boolean;
+  };
+}
+
+const TOOL_MAP: Record<string, keyof ContextModeStatus["tools"]> = {
+  ctx_execute: "ctxExecute",
+  ctx_batch_execute: "ctxBatchExecute",
+  ctx_execute_file: "ctxExecuteFile",
+  ctx_index: "ctxIndex",
+  ctx_search: "ctxSearch",
+  ctx_fetch_and_index: "ctxFetchAndIndex",
+};
+
+/** Detect context-mode MCP tool availability from the active tools list */
+export function detectContextMode(activeTools: string[]): ContextModeStatus {
+  const tools: ContextModeStatus["tools"] = {
+    ctxExecute: false,
+    ctxBatchExecute: false,
+    ctxExecuteFile: false,
+    ctxIndex: false,
+    ctxSearch: false,
+    ctxFetchAndIndex: false,
+  };
+
+  for (const tool of activeTools) {
+    const key = TOOL_MAP[tool];
+    if (key) tools[key] = true;
+  }
+
+  const available = Object.values(tools).some(Boolean);
+  return { available, tools };
+}

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

@@ -0,0 +1,170 @@
+// src/context-mode/event-extractor.ts
+import type { EventCategory, EventPriority, TrackedEvent } from "./event-store.js";
+
+type Event = Omit<TrackedEvent, "id">;
+
+const GIT_COMMAND_PATTERNS = [
+  /^git\s+(commit|merge|rebase|checkout|switch|branch|push|pull|stash|reset|cherry-pick|tag)\b/,
+];
+
+const DECISION_PATTERNS = [
+  /\blet'?s?\s+go\s+with\b/i,
+  /\buse\s+\S+\s+instead\s+of\b/i,
+  /\bi\s+want\b/i,
+  /\bgo\s+ahead\b/i,
+  /^(yes|no|yep|nope|sure|ok|okay)\b/i,
+  /\bdo\s+that\b/i,
+  /\blet'?s?\s+do\b/i,
+  /\bpick\s+(option|approach|choice)\b/i,
+];
+
+function makeEvent(
+  sessionId: string,
+  category: EventCategory,
+  data: Record<string, unknown>,
+  priority: EventPriority,
+  source: string,
+): Event {
+  return {
+    sessionId,
+    category,
+    data: JSON.stringify(data),
+    priority,
+    source,
+    timestamp: Date.now(),
+  };
+}
+
+function getTextContent(content: Array<{ type: string; text?: string }>): string {
+  return content
+    .filter((c) => c.type === "text" && c.text)
+    .map((c) => c.text!)
+    .join("\n")
+    .slice(0, 500); // Cap for storage
+}
+
+/** Extract events from a tool result */
+export function extractEvents(
+  event: {
+    toolName: string;
+    input: Record<string, unknown>;
+    content: Array<{ type: string; text?: string }>;
+    isError: boolean;
+    details: unknown;
+  },
+  sessionId: string,
+): Event[] {
+  const events: Event[] = [];
+  const text = getTextContent(event.content);
+
+  // General rule: emit error event for any isError result
+  if (event.isError) {
+    events.push(makeEvent(sessionId, "error", {
+      toolName: event.toolName,
+      content: text,
+    }, "critical", "tool_result"));
+  }
+
+  switch (event.toolName) {
+    case "bash":
+      extractBash(events, event, sessionId, text);
+      break;
+    case "read":
+      extractFile(events, event, sessionId, "read");
+      break;
+    case "edit":
+      extractFile(events, event, sessionId, "edit", "high");
+      break;
+    case "write":
+      extractFile(events, event, sessionId, "write", "high");
+      break;
+    case "grep":
+      extractFile(events, event, sessionId, "search");
+      break;
+    case "find":
+      extractFile(events, event, sessionId, "find");
+      break;
+    case "todo_write":
+      events.push(makeEvent(sessionId, "task", {
+        input: event.input,
+      }, "high", "tool_result"));
+      break;
+    default:
+      if (event.toolName.startsWith("ctx_")) {
+        events.push(makeEvent(sessionId, "mcp", {
+          tool: event.toolName,
+        }, "low", "tool_result"));
+      } else if (event.toolName === "task" || event.toolName === "sub_agent") {
+        events.push(makeEvent(sessionId, "subagent", {
+          toolName: event.toolName,
+          input: event.input,
+        }, "medium", "tool_result"));
+      }
+      // Unknown tools: no events
+      break;
+  }
+
+  return events;
+}
+
+function extractBash(
+  events: Event[],
+  event: { input: Record<string, unknown>; details: unknown },
+  sessionId: string,
+  text: string,
+): void {
+  const command = typeof event.input.command === "string" ? event.input.command : "";
+  const exitCode = event.details && typeof event.details === "object" && "exitCode" in event.details
+    ? (event.details as { exitCode: number }).exitCode
+    : 0;
+
+  // Git operations
+  if (GIT_COMMAND_PATTERNS.some((p) => p.test(command))) {
+    events.push(makeEvent(sessionId, "git", {
+      command,
+      output: text,
+    }, "high", "tool_result"));
+  }
+
+  // Non-zero exit (in addition to general isError rule)
+  if (exitCode !== 0) {
+    events.push(makeEvent(sessionId, "error", {
+      command,
+      exitCode,
+      output: text,
+    }, "critical", "tool_result"));
+  }
+
+  // Working directory change
+  if (/\bcd\s+/.test(command)) {
+    events.push(makeEvent(sessionId, "cwd", {
+      command,
+    }, "low", "tool_result"));
+  }
+}
+
+function extractFile(
+  events: Event[],
+  event: { input: Record<string, unknown> },
+  sessionId: string,
+  op: string,
+  priority: EventPriority = "medium",
+): void {
+  const path = typeof event.input.path === "string" ? event.input.path : "unknown";
+  events.push(makeEvent(sessionId, "file", { op, path }, priority, "tool_result"));
+}
+
+/** Extract events from a user prompt (called from before_agent_start handler) */
+export function extractPromptEvents(prompt: string, sessionId: string): Event[] {
+  const events: Event[] = [];
+
+  // Always capture the prompt
+  events.push(makeEvent(sessionId, "prompt", { prompt }, "high", "before_agent_start"));
+
+  // Check for decision patterns
+  if (DECISION_PATTERNS.some((p) => p.test(prompt))) {
+    events.push(makeEvent(sessionId, "decision", { prompt }, "high", "before_agent_start"));
+  }
+
+  return events;
+}

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

@@ -0,0 +1,168 @@
+// src/context-mode/event-store.ts
+import { Database } from "bun:sqlite";
+
+/** Event categories extracted from tool results */
+export type EventCategory =
+  | "file"
+  | "git"
+  | "error"
+  | "task"
+  | "cwd"
+  | "mcp"
+  | "subagent"
+  | "prompt"
+  | "decision";
+
+/** Priority levels for resume snapshot ordering */
+export type EventPriority = "critical" | "high" | "medium" | "low";
+
+/** A tracked event */
+export interface TrackedEvent {
+  id?: number;
+  sessionId: string;
+  category: EventCategory;
+  data: string;
+  priority: EventPriority;
+  source: string;
+  timestamp: number;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS session_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  category TEXT NOT NULL,
+  data TEXT NOT NULL,
+  priority TEXT NOT NULL DEFAULT 'medium',
+  source TEXT NOT NULL,
+  timestamp INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session ON session_events(session_id, timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_category ON session_events(session_id, category);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS session_events_fts USING fts5(
+  data,
+  content=session_events,
+  content_rowid=id
+);
+
+CREATE TRIGGER IF NOT EXISTS events_ai AFTER INSERT ON session_events BEGIN
+  INSERT INTO session_events_fts(rowid, data) VALUES (new.id, new.data);
+END;
+
+CREATE TRIGGER IF NOT EXISTS events_ad AFTER DELETE ON session_events BEGIN
+  INSERT INTO session_events_fts(session_events_fts, rowid, data) VALUES ('delete', old.id, old.data);
+END;
+
+CREATE TRIGGER IF NOT EXISTS events_au AFTER UPDATE ON session_events BEGIN
+  INSERT INTO session_events_fts(session_events_fts, rowid, data) VALUES ('delete', old.id, old.data);
+  INSERT INTO session_events_fts(rowid, data) VALUES (new.id, new.data);
+END;
+`;
+
+const ALL_CATEGORIES: EventCategory[] = [
+  "file", "git", "error", "task", "cwd", "mcp", "subagent", "prompt", "decision",
+];
+
+export class EventStore {
+  private db: Database;
+
+  constructor(dbPath: string) {
+    this.db = new Database(dbPath);
+  }
+
+  init(): void {
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.db.exec(SCHEMA);
+  }
+
+  writeEvent(event: Omit<TrackedEvent, "id">): void {
+    this.db.run(
+      "INSERT INTO session_events (session_id, category, data, priority, source, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
+      [event.sessionId, event.category, event.data, event.priority, event.source, event.timestamp],
+    );
+  }
+
+  writeEvents(events: Omit<TrackedEvent, "id">[]): void {
+    const insert = this.db.prepare(
+      "INSERT INTO session_events (session_id, category, data, priority, source, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
+    );
+    const tx = this.db.transaction(() => {
+      for (const event of events) {
+        insert.run(event.sessionId, event.category, event.data, event.priority, event.source, event.timestamp);
+      }
+    });
+    tx();
+  }
+
+  getEvents(
+    sessionId: string,
+    filters?: {
+      categories?: EventCategory[];
+      priority?: EventPriority;
+      since?: number;
+      limit?: number;
+    },
+  ): TrackedEvent[] {
+    const conditions = ["session_id = ?"];
+    const params: (string | number)[] = [sessionId];
+
+    if (filters?.categories?.length) {
+      conditions.push(`category IN (${filters.categories.map(() => "?").join(",")})`);
+      params.push(...filters.categories);
+    }
+    if (filters?.priority) {
+      conditions.push("priority = ?");
+      params.push(filters.priority);
+    }
+    if (filters?.since) {
+      conditions.push("timestamp > ?");
+      params.push(filters.since);
+    }
+
+    let sql = `SELECT id, session_id AS sessionId, category, data, priority, source, timestamp FROM session_events WHERE ${conditions.join(" AND ")} ORDER BY timestamp DESC`;
+
+    if (filters?.limit) {
+      sql += " LIMIT ?";
+      params.push(filters.limit);
+    }
+
+    return this.db.prepare(sql).all(...params) as TrackedEvent[];
+  }
+
+  searchEvents(sessionId: string, query: string, limit = 20): TrackedEvent[] {
+    const sql = `
+      SELECT e.id, e.session_id AS sessionId, e.category, e.data, e.priority, e.source, e.timestamp
+      FROM session_events_fts fts
+      JOIN session_events e ON e.id = fts.rowid
+      WHERE fts.data MATCH ? AND e.session_id = ?
+      ORDER BY rank
+      LIMIT ?
+    `;
+    return this.db.prepare(sql).all(query, sessionId, limit) as TrackedEvent[];
+  }
+
+  getEventCounts(sessionId: string): Record<EventCategory, number> {
+    const rows = this.db.prepare(
+      "SELECT category, COUNT(*) AS count FROM session_events WHERE session_id = ? GROUP BY category",
+    ).all(sessionId) as Array<{ category: EventCategory; count: number }>;
+
+    const counts = {} as Record<EventCategory, number>;
+    for (const cat of ALL_CATEGORIES) counts[cat] = 0;
+    for (const row of rows) counts[row.category] = row.count;
+    return counts;
+  }
+
+  pruneEvents(olderThan: number): number {
+    const countRow = this.db.prepare("SELECT COUNT(*) AS count FROM session_events WHERE timestamp < ?").get(olderThan) as { count: number };
+    if (countRow.count > 0) {
+      this.db.prepare("DELETE FROM session_events WHERE timestamp < ?").run(olderThan);
+    }
+    return countRow.count;
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}