supipowers 1.2.6 → 1.3.0

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

@@ -1,7 +1,8 @@
 // src/context-mode/event-extractor.ts
+import { PRIORITY } from "./event-store.js";
 import type { EventCategory, EventPriority, TrackedEvent } from "./event-store.js";
 
-type Event = Omit<TrackedEvent, "id">;
+type Event = Omit<TrackedEvent, "id" | "dataHash">;
 
 const GIT_COMMAND_PATTERNS = [
   /^git\s+(commit|merge|rebase|checkout|switch|branch|push|pull|stash|reset|cherry-pick|tag)\b/,
@@ -39,8 +40,7 @@ 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
+    .join("\n");
 }
 
 /** Extract events from a tool result */
@@ -62,21 +62,29 @@ export function extractEvents(
     events.push(makeEvent(sessionId, "error", {
       toolName: event.toolName,
       content: text,
-    }, "critical", "tool_result"));
+    }, PRIORITY.critical, "tool_result"));
   }
 
   switch (event.toolName) {
     case "bash":
       extractBash(events, event, sessionId, text);
       break;
-    case "read":
+    case "read": {
+      const readPath = typeof event.input.path === "string" ? event.input.path : "";
+      if (/AGENTS\.md$/.test(readPath) || /CLAUDE\.md$/.test(readPath) || /\.omp\//.test(readPath)) {
+        events.push(makeEvent(sessionId, "rule", { path: readPath, type: "project-rule" }, PRIORITY.critical, "tool_result"));
+      }
+      if (readPath.includes("/skills/")) {
+        events.push(makeEvent(sessionId, "skill", { path: readPath }, PRIORITY.medium, "tool_result"));
+      }
       extractFile(events, event, sessionId, "read");
       break;
+    }
     case "edit":
-      extractFile(events, event, sessionId, "edit", "high");
+      extractFile(events, event, sessionId, "edit", PRIORITY.high);
       break;
     case "write":
-      extractFile(events, event, sessionId, "write", "high");
+      extractFile(events, event, sessionId, "write", PRIORITY.high);
       break;
     case "grep":
       extractFile(events, event, sessionId, "search");
@@ -87,18 +95,18 @@ export function extractEvents(
     case "todo_write":
       events.push(makeEvent(sessionId, "task", {
         input: event.input,
-      }, "high", "tool_result"));
+      }, PRIORITY.high, "tool_result"));
       break;
     default:
       if (event.toolName.startsWith("ctx_")) {
         events.push(makeEvent(sessionId, "mcp", {
           tool: event.toolName,
-        }, "low", "tool_result"));
+        }, PRIORITY.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"));
+        }, PRIORITY.medium, "tool_result"));
       }
       // Unknown tools: no events
       break;
@@ -123,7 +131,7 @@ function extractBash(
     events.push(makeEvent(sessionId, "git", {
       command,
       output: text,
-    }, "high", "tool_result"));
+    }, PRIORITY.high, "tool_result"));
   }
 
   // Non-zero exit (in addition to general isError rule)
@@ -132,14 +140,28 @@ function extractBash(
       command,
       exitCode,
       output: text,
-    }, "critical", "tool_result"));
+    }, PRIORITY.critical, "tool_result"));
   }
 
   // Working directory change
   if (/\bcd\s+/.test(command)) {
     events.push(makeEvent(sessionId, "cwd", {
       command,
-    }, "low", "tool_result"));
+    }, PRIORITY.low, "tool_result"));
+  }
+
+  // Environment/version commands
+  const ENV_PATTERNS = [
+    /^(node|bun|python|ruby|go)\s+--?version/,
+    /^(npm|yarn|pnpm|pip|cargo)\s+--?version/,
+    /\bprintenv\b/,
+    /\becho\s+\$\w+/,
+  ];
+  if (ENV_PATTERNS.some((p) => p.test(command))) {
+    events.push(makeEvent(sessionId, "env", {
+      command,
+      output: text,
+    }, PRIORITY.medium, "tool_result"));
   }
 }
 
@@ -148,7 +170,7 @@ function extractFile(
   event: { input: Record<string, unknown> },
   sessionId: string,
   op: string,
-  priority: EventPriority = "medium",
+  priority: EventPriority = PRIORITY.medium,
 ): void {
   const path = typeof event.input.path === "string" ? event.input.path : "unknown";
   events.push(makeEvent(sessionId, "file", { op, path }, priority, "tool_result"));
@@ -159,11 +181,18 @@ 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"));
+  events.push(makeEvent(sessionId, "prompt", { prompt }, PRIORITY.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"));
+    events.push(makeEvent(sessionId, "decision", { prompt }, PRIORITY.high, "before_agent_start"));
+  }
+
+  // Detect high-level intent markers
+  const INTENT_PATTERN = /\b(build|fix|refactor|test|review|deploy|debug|plan|implement|create|delete|remove|update|add|migrate)\b/i;
+  const intentMatch = prompt.match(INTENT_PATTERN);
+  if (intentMatch) {
+    events.push(makeEvent(sessionId, "intent", { intent: intentMatch[1].toLowerCase(), prompt }, PRIORITY.low, "before_agent_start"));
   }
 
   return events;

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

@@ -1,5 +1,6 @@
 // src/context-mode/event-store.ts
 import { Database } from "bun:sqlite";
+import { createHash } from "node:crypto";
 
 /** Event categories extracted from tool results */
 export type EventCategory =
@@ -11,10 +12,23 @@ export type EventCategory =
   | "mcp"
   | "subagent"
   | "prompt"
-  | "decision";
+  | "decision"
+  | "rule"
+  | "env"
+  | "skill"
+  | "intent";
 
-/** Priority levels for resume snapshot ordering */
-export type EventPriority = "critical" | "high" | "medium" | "low";
+/** Numeric priority: 1 = critical … 5 = lowest */
+export type EventPriority = 1 | 2 | 3 | 4 | 5;
+
+/** Named priority constants — use instead of magic numbers */
+export const PRIORITY = {
+  critical: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+  lowest: 5,
+} as const satisfies Record<string, EventPriority>;
 
 /** A tracked event */
 export interface TrackedEvent {
@@ -25,21 +39,47 @@ export interface TrackedEvent {
   priority: EventPriority;
   source: string;
   timestamp: number;
+  dataHash?: string;
+}
+
+/** Session metadata row */
+export interface SessionMeta {
+  sessionId: string;
+  projectDir: string;
+  startedAt: string;
+  lastEventAt: string;
+  eventCount: number;
+  compactCount: number;
+}
+
+/** Resume snapshot row */
+export interface SessionResume {
+  sessionId: string;
+  snapshot: string;
+  eventCount: number;
+  createdAt: string;
+  consumed: boolean;
 }
 
+const MAX_EVENTS_PER_SESSION = 1000;
+const DEDUP_WINDOW = 5;
+const SCHEMA_VERSION = 1;
+
 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',
+  priority INTEGER NOT NULL DEFAULT 3,
   source TEXT NOT NULL,
-  timestamp INTEGER NOT NULL
+  timestamp INTEGER NOT NULL,
+  data_hash TEXT NOT NULL DEFAULT ''
 );
 
 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 INDEX IF NOT EXISTS idx_events_dedup ON session_events(session_id, data_hash);
 
 CREATE VIRTUAL TABLE IF NOT EXISTS session_events_fts USING fts5(
   data,
@@ -59,12 +99,36 @@ 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;
+
+CREATE TABLE IF NOT EXISTS session_meta (
+  session_id TEXT UNIQUE NOT NULL,
+  project_dir TEXT NOT NULL DEFAULT '',
+  started_at TEXT NOT NULL DEFAULT (datetime('now')),
+  last_event_at TEXT NOT NULL DEFAULT (datetime('now')),
+  event_count INTEGER NOT NULL DEFAULT 0,
+  compact_count INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS session_resume (
+  id INTEGER PRIMARY KEY,
+  session_id TEXT UNIQUE NOT NULL,
+  snapshot TEXT NOT NULL,
+  event_count INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  consumed INTEGER NOT NULL DEFAULT 0
+);
 `;
 
-const ALL_CATEGORIES: EventCategory[] = [
+export const ALL_CATEGORIES: EventCategory[] = [
   "file", "git", "error", "task", "cwd", "mcp", "subagent", "prompt", "decision",
+  "rule", "env", "skill", "intent",
 ];
 
+/** SHA-256 first 16 hex chars — fast content-addressable dedup key */
+function computeDataHash(data: string): string {
+  return createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+
 export class EventStore {
   private db: Database;
 
@@ -74,27 +138,94 @@ export class EventStore {
 
   init(): void {
     this.db.exec("PRAGMA journal_mode = WAL;");
+    this.migrate();
     this.db.exec(SCHEMA);
   }
 
-  writeEvent(event: Omit<TrackedEvent, "id">): void {
+  // ── Schema migration ────────────────────────────────────────
+
+  private migrate(): void {
+    const { user_version } = this.db.prepare("PRAGMA user_version").get() as { user_version: number };
+    if (user_version >= SCHEMA_VERSION) return;
+
+    // Upgrade from v0: session_events exists but lacks data_hash column
+    const tableExists = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='session_events'",
+    ).get();
+
+    if (tableExists) {
+      try {
+        this.db.exec("ALTER TABLE session_events ADD COLUMN data_hash TEXT NOT NULL DEFAULT ''");
+      } catch {
+        // Column already exists (fresh install ran SCHEMA first somehow)
+      }
+    }
+
+    this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION};`);
+  }
+
+  // ── Write with dedup + eviction ─────────────────────────────
+
+  writeEvent(event: Omit<TrackedEvent, "id" | "dataHash">): void {
+    const dataHash = computeDataHash(event.data);
+    if (this.isDuplicate(event.sessionId, event.category, dataHash)) return;
+
     this.db.prepare(
-      "INSERT INTO session_events (session_id, category, data, priority, source, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
-    ).run(event.sessionId, event.category, event.data, event.priority, event.source, event.timestamp);
+      "INSERT INTO session_events (session_id, category, data, priority, source, timestamp, data_hash) VALUES (?, ?, ?, ?, ?, ?, ?)",
+    ).run(event.sessionId, event.category, event.data, event.priority, event.source, event.timestamp, dataHash);
+
+    this.enforceEventCap(event.sessionId);
   }
 
-  writeEvents(events: Omit<TrackedEvent, "id">[]): void {
+  writeEvents(events: Omit<TrackedEvent, "id" | "dataHash">[]): void {
+    if (events.length === 0) return;
+
     const insert = this.db.prepare(
-      "INSERT INTO session_events (session_id, category, data, priority, source, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
+      "INSERT INTO session_events (session_id, category, data, priority, source, timestamp, data_hash) 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);
+        const dataHash = computeDataHash(event.data);
+        if (this.isDuplicate(event.sessionId, event.category, dataHash)) continue;
+        insert.run(event.sessionId, event.category, event.data, event.priority, event.source, event.timestamp, dataHash);
       }
     });
     tx();
+
+    this.enforceEventCap(events[0].sessionId);
+  }
+
+  /** Check last DEDUP_WINDOW events for same category + content hash */
+  private isDuplicate(sessionId: string, category: string, dataHash: string): boolean {
+    const row = this.db.prepare(
+      `SELECT 1 FROM (
+        SELECT category, data_hash FROM session_events
+        WHERE session_id = ? ORDER BY id DESC LIMIT ?
+      ) WHERE category = ? AND data_hash = ? LIMIT 1`,
+    ).get(sessionId, DEDUP_WINDOW, category, dataHash);
+    return row != null;
   }
 
+  /** Delete lowest-priority (highest number), then oldest events to stay at cap */
+  private enforceEventCap(sessionId: string): void {
+    const { count } = this.db.prepare(
+      "SELECT COUNT(*) AS count FROM session_events WHERE session_id = ?",
+    ).get(sessionId) as { count: number };
+
+    if (count <= MAX_EVENTS_PER_SESSION) return;
+
+    const excess = count - MAX_EVENTS_PER_SESSION;
+    this.db.prepare(
+      `DELETE FROM session_events WHERE id IN (
+        SELECT id FROM session_events WHERE session_id = ?
+        ORDER BY CAST(priority AS INTEGER) DESC, timestamp ASC
+        LIMIT ?
+      )`,
+    ).run(sessionId, excess);
+  }
+
+  // ── Read ────────────────────────────────────────────────────
+
   getEvents(
     sessionId: string,
     filters?: {
@@ -112,7 +243,7 @@ export class EventStore {
       params.push(...filters.categories);
     }
     if (filters?.priority) {
-      conditions.push("priority = ?");
+      conditions.push("CAST(priority AS INTEGER) = ?");
       params.push(filters.priority);
     }
     if (filters?.since) {
@@ -120,7 +251,7 @@ export class EventStore {
       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`;
+    let sql = `SELECT id, session_id AS sessionId, category, data, priority, source, timestamp, data_hash AS dataHash FROM session_events WHERE ${conditions.join(" AND ")} ORDER BY timestamp DESC`;
 
     if (filters?.limit) {
       sql += " LIMIT ?";
@@ -132,7 +263,8 @@ export class EventStore {
 
   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
+      SELECT e.id, e.session_id AS sessionId, e.category, e.data, e.priority,
+             e.source, e.timestamp, e.data_hash AS dataHash
       FROM session_events_fts fts
       JOIN session_events e ON e.id = fts.rowid
       WHERE fts.data MATCH ? AND e.session_id = ?
@@ -153,14 +285,91 @@ export class EventStore {
     return counts;
   }
 
+  // ── Session metadata ────────────────────────────────────────
+
+  upsertMeta(sessionId: string, projectDir: string): void {
+    this.db.prepare(
+      `INSERT INTO session_meta (session_id, project_dir, event_count)
+       VALUES (?, ?, 0)
+       ON CONFLICT(session_id) DO UPDATE SET
+         last_event_at = datetime('now'),
+         event_count = event_count + 1`,
+    ).run(sessionId, projectDir);
+  }
+
+  getMeta(sessionId: string): SessionMeta | null {
+    const row = this.db.prepare(
+      `SELECT session_id AS sessionId, project_dir AS projectDir,
+              started_at AS startedAt, last_event_at AS lastEventAt,
+              event_count AS eventCount, compact_count AS compactCount
+       FROM session_meta WHERE session_id = ?`,
+    ).get(sessionId) as SessionMeta | undefined;
+    return row ?? null;
+  }
+
+  incrementCompactCount(sessionId: string): void {
+    this.db.prepare(
+      "UPDATE session_meta SET compact_count = compact_count + 1 WHERE session_id = ?",
+    ).run(sessionId);
+  }
+
+  // ── Resume snapshots ────────────────────────────────────────
+
+  upsertResume(sessionId: string, snapshot: string, eventCount: number): void {
+    this.db.prepare(
+      `INSERT INTO session_resume (session_id, snapshot, event_count, consumed)
+       VALUES (?, ?, ?, 0)
+       ON CONFLICT(session_id) DO UPDATE SET
+         snapshot = excluded.snapshot,
+         event_count = excluded.event_count,
+         created_at = datetime('now'),
+         consumed = 0`,
+    ).run(sessionId, snapshot, eventCount);
+  }
+
+  getResume(sessionId: string): SessionResume | null {
+    const row = this.db.prepare(
+      `SELECT session_id AS sessionId, snapshot, event_count AS eventCount,
+              created_at AS createdAt, consumed
+       FROM session_resume WHERE session_id = ? AND consumed = 0`,
+    ).get(sessionId) as (Omit<SessionResume, "consumed"> & { consumed: number }) | undefined;
+    if (!row) return null;
+    return { ...row, consumed: row.consumed !== 0 };
+  }
+
+  consumeResume(sessionId: string): void {
+    this.db.prepare(
+      "UPDATE session_resume SET consumed = 1 WHERE session_id = ?",
+    ).run(sessionId);
+  }
+
+  // ── Maintenance ─────────────────────────────────────────────
+
   pruneEvents(olderThan: number): number {
-    const countRow = this.db.prepare("SELECT COUNT(*) AS count FROM session_events WHERE timestamp < ?").get(olderThan) as { count: 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;
   }
 
+  pruneOldSessions(retentionDays = 7): number {
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    const pruned = this.pruneEvents(cutoff);
+    // Remove orphaned metadata for sessions with no remaining events
+    this.db.exec(`
+      DELETE FROM session_meta WHERE session_id NOT IN (
+        SELECT DISTINCT session_id FROM session_events
+      );
+      DELETE FROM session_resume WHERE session_id NOT IN (
+        SELECT DISTINCT session_id FROM session_events
+      );
+    `);
+    return pruned;
+  }
+
   close(): void {
     this.db.close();
   }

package/src/context-mode/hooks.ts

@@ -106,22 +106,77 @@ export function registerContextModeHooks(platform: Platform, config: SupipowersC
 
   // Phase 3: Compaction integration
   if (config.contextMode.compaction && eventStore) {
-    let pendingSnapshot: string | null = null;
+    // Initialize session metadata for compact tracking
+    try {
+      eventStore.upsertMeta(sessionId, process.cwd());
+    } catch {
+      // Non-fatal: metadata is supplementary
+    }
 
     platform.on("session_before_compact", () => {
+      // Re-detect MCP tools: they may have loaded since init
+      const status = cachedStatus ?? detectContextMode(platform.getActiveTools());
+      const searchAvailable = status.tools.ctxSearch;
+
+      // Determine the search tool name for reference-based snapshots
+      let searchTool: string | undefined;
+      if (searchAvailable) {
+        const tools = platform.getActiveTools();
+        searchTool = tools.find((t) => t.includes("ctx_search"));
+      }
+
+      // Read compact count from metadata
+      let compactCount = 0;
       try {
-        pendingSnapshot = buildResumeSnapshot(eventStore!, sessionId);
+        const meta = eventStore!.getMeta(sessionId);
+        compactCount = meta?.compactCount ?? 0;
+      } catch {
+        // Non-fatal
+      }
+
+      try {
+        const snapshot = buildResumeSnapshot(eventStore!, sessionId, {
+          compactCount,
+          searchTool,
+          searchAvailable,
+        });
+
+        // Persist to DB so it survives crashes
+        if (snapshot) {
+          const eventCount = Object.values(eventStore!.getEventCounts(sessionId))
+            .reduce((a, b) => a + b, 0);
+          eventStore!.upsertResume(sessionId, snapshot, eventCount);
+        }
+
+        return undefined; // don't cancel or replace compaction
       } catch (e) {
         (platform as any).logger?.warn?.("context-mode: snapshot build failed", e);
-        pendingSnapshot = null;
+        return undefined;
       }
-      return undefined; // don't cancel or replace compaction
     });
 
     platform.on("session_compact", () => {
-      if (!pendingSnapshot) return undefined;
-      const snapshot = pendingSnapshot;
-      pendingSnapshot = null;
+      // Try resume from DB first, fall back to in-memory
+      let snapshot: string | null = null;
+      try {
+        const resume = eventStore!.getResume(sessionId);
+        if (resume) {
+          snapshot = resume.snapshot;
+          eventStore!.consumeResume(sessionId);
+        }
+      } catch {
+        // Non-fatal: fall through
+      }
+
+      if (!snapshot) return undefined;
+
+      // Track compaction count in session metadata
+      try {
+        eventStore!.incrementCompactCount(sessionId);
+      } catch {
+        // Non-fatal
+      }
+
       return {
         context: snapshot.split("\n"),
         preserveData: {

package/src/context-mode/routing.ts

@@ -7,7 +7,13 @@ const HTTP_PATTERNS = [
   /^\s*wget\s/,
   /\bcurl\s+(-[a-zA-Z]*\s+)*https?:\/\//,
   /\bwget\s+(-[a-zA-Z]*\s+)*https?:\/\//,
-];
+  // Inline HTTP patterns
+  /\bfetch\s*\(/,
+  /\brequests\.(get|post|put|delete|patch)\s*\(/,
+  /\bhttp\.(get|request)\s*\(/,
+  /\burllib\.request/,
+  /\bInvoke-WebRequest/,
+]; 
 
 /** Bash commands that are search/find operations */
 const BASH_SEARCH_PATTERNS = [
@@ -41,10 +47,10 @@ export function isBashSearchCommand(command: unknown): boolean {
   return BASH_SEARCH_PATTERNS.some((p) => p.test(command));
 }
 
-/** Check if a Read call is a full-file read (no limit/offset = likely analysis, not edit prep) */
+/** Check if a Read call is a full-file read (no limit/offset/sel = likely analysis, not edit prep) */
 export function isFullFileRead(input: Record<string, unknown> | undefined): boolean {
   if (!input) return true;
-  return input.limit == null && input.offset == null;
+  return input.limit == null && input.offset == null && input.sel == null;
 }
 
 /** Block result returned by routing functions */
@@ -95,17 +101,6 @@ export function routeToolCall(
     };
   }
 
-  // Read (full-file, no limit/offset) → block, redirect to ctx_execute_file
-  if (options.enforceRouting && toolName === "read") {
-    if (!status.tools.ctxExecuteFile) return undefined;
-    if (!isFullFileRead(input)) return undefined;
-    return {
-      block: true,
-      reason:
-        "Use ctx_execute_file(path, language, code) for file analysis instead of Read. " +
-        "If you need to Read before editing, re-call with a limit parameter.",
-    };
-  }
 
   // Bash routing
   if (toolName === "bash") {