@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-hermes-memory/src/handlers/child-process-watchdog.mjs

@@ -0,0 +1,90 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+
+const [timeoutValue, cancellationPath, command, ...args] = process.argv.slice(2);
+const timeoutMs = Number(timeoutValue);
+
+if (!cancellationPath || !command || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+  process.stderr.write("pi-hermes-memory watchdog: invalid invocation\n");
+  process.exit(2);
+}
+
+const child = spawn(command, args, {
+  detached: process.platform !== "win32",
+  stdio: ["ignore", "pipe", "pipe"],
+});
+
+child.stdout?.pipe(process.stdout);
+child.stderr?.pipe(process.stderr);
+
+let timedOut = false;
+let cancelled = false;
+let terminating = false;
+let forceTimer;
+
+function signalTree(signal) {
+  if (!child.pid) return;
+  if (process.platform === "win32") {
+    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    killer.unref();
+    return;
+  }
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    try { child.kill(signal); } catch {}
+  }
+}
+
+function terminateTree() {
+  if (terminating) return;
+  terminating = true;
+  signalTree("SIGTERM");
+  forceTimer = setTimeout(() => signalTree("SIGKILL"), 500);
+  forceTimer.unref();
+}
+
+const timeout = setTimeout(() => {
+  timedOut = true;
+  process.stderr.write(`[pi-hermes-memory] child timed out after ${timeoutMs}ms; terminating process tree\n`);
+  terminateTree();
+}, timeoutMs);
+timeout.unref();
+
+const cancellationPoll = cancellationPath === "-" ? undefined : setInterval(() => {
+  if (!existsSync(cancellationPath)) return;
+  cancelled = true;
+  process.stderr.write("[pi-hermes-memory] child cancellation requested; terminating process tree\n");
+  terminateTree();
+}, 25);
+cancellationPoll?.unref();
+
+for (const signal of ["SIGTERM", "SIGINT"]) {
+  process.on(signal, terminateTree);
+}
+
+child.once("error", (error) => {
+  clearTimeout(timeout);
+  if (cancellationPoll) clearInterval(cancellationPoll);
+  if (forceTimer) clearTimeout(forceTimer);
+  process.stderr.write(`pi-hermes-memory watchdog: ${error.message}\n`);
+  process.exitCode = timedOut ? 124 : cancelled ? 143 : 127;
+});
+
+child.once("close", (code, signal) => {
+  clearTimeout(timeout);
+  if (cancellationPoll) clearInterval(cancellationPoll);
+  if (forceTimer) clearTimeout(forceTimer);
+  if (timedOut) {
+    process.exitCode = 124;
+  } else if (cancelled) {
+    process.exitCode = 143;
+  } else if (typeof code === "number") {
+    process.exitCode = code;
+  } else {
+    process.exitCode = signal === "SIGTERM" ? 143 : 1;
+  }
+});

package/dist/extensions/pi-hermes-memory/src/handlers/correction-detector.ts

@@ -0,0 +1,300 @@
+/**
+ * Correction detection — detects user corrections in real-time and triggers
+ * an immediate memory save instead of waiting for the next nudge interval.
+ *
+ * Uses a two-pass filter:
+ * - Strong patterns: always trigger (high confidence)
+ * - Weak patterns: only trigger if followed by a directive clause
+ * - Negative patterns: suppress even if a positive pattern matched
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { MemoryStore } from "../store/memory-store.js";
+import { DatabaseManager } from "../store/db.js";
+import {
+  buildMemoryTargetRoutingGuidance,
+  CORRECTION_SAVE_PROMPT,
+  CORRECTION_STRONG_PATTERNS,
+  CORRECTION_WEAK_PATTERNS,
+  CORRECTION_NEGATIVE_PATTERNS,
+  CORRECTION_DIRECTIVE_WORDS,
+  DIRECT_CORRECTION_SYSTEM_PROMPT,
+  ENTRY_DELIMITER,
+} from "../constants.js";
+import type { MemoryConfig } from "../types.js";
+import { getMessageText } from "../types.js";
+import { execChildPrompt, resolveChildPiModel } from "./pi-child-process.js";
+import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
+import { runDirectMemoryCompletion, usesDirectTransport } from "./review-memory-ops.js";
+
+/**
+ * Extract the directive part from a correction message.
+ * E.g., "no, use pnpm instead" -> "use pnpm instead"
+ */
+function extractCorrectionDirective(text: string): string {
+  // Remove common correction starters
+  const cleaned = text
+    .replace(/^(no|wrong|actually|stop|don'?t|that'?s not|I said|I told you)[,\.\s!]+/i, '')
+    .replace(/^(please\s+)?/i, '')
+    .trim();
+  return cleaned || text;
+}
+
+function compileCorrectionPatterns(
+  configured: string[] | undefined,
+  defaults: RegExp[],
+): RegExp[] {
+  if (configured === undefined) return defaults;
+
+  const patterns: RegExp[] = [];
+  for (const source of configured) {
+    try {
+      patterns.push(new RegExp(source, "i"));
+    } catch {
+      // Ignore invalid configured regex entries; valid entries still apply.
+    }
+  }
+  return patterns;
+}
+
+function escapeRegexLiteral(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function hasDirectiveWord(remainder: string, words: string[]): boolean {
+  if (words.length === 0) return false;
+  const source = words.map(escapeRegexLiteral).join("|");
+  return new RegExp(`\\b(${source})\\b`, "i").test(remainder);
+}
+
+/**
+ * Check if a user message is a correction using the two-pass filter.
+ * Returns true if the message should trigger an immediate save.
+ */
+type CorrectionPatternConfig = Pick<MemoryConfig,
+  "correctionStrongPatterns" |
+  "correctionWeakPatterns" |
+  "correctionNegativePatterns" |
+  "correctionDirectiveWords"
+>;
+
+export function isCorrection(text: string, config?: CorrectionPatternConfig): boolean {
+  const negativePatterns = compileCorrectionPatterns(
+    config?.correctionNegativePatterns,
+    CORRECTION_NEGATIVE_PATTERNS,
+  );
+  const strongPatterns = compileCorrectionPatterns(
+    config?.correctionStrongPatterns,
+    CORRECTION_STRONG_PATTERNS,
+  );
+  const weakPatterns = compileCorrectionPatterns(
+    config?.correctionWeakPatterns,
+    CORRECTION_WEAK_PATTERNS,
+  );
+  const directiveWords = config?.correctionDirectiveWords ?? CORRECTION_DIRECTIVE_WORDS;
+
+  // Check negative patterns first — suppress even if positive matches
+  for (const pattern of negativePatterns) {
+    if (pattern.test(text)) return false;
+  }
+
+  // Check strong patterns — always trigger
+  for (const pattern of strongPatterns) {
+    if (pattern.test(text)) return true;
+  }
+
+  // Check weak patterns — only trigger if followed by a directive clause
+  for (const pattern of weakPatterns) {
+    if (pattern.test(text)) {
+      // Look for a directive after the weak pattern match
+      // Directive = a verb or "the/that/this" in the remainder of the text
+      const match = pattern.exec(text);
+      if (match && match.index === 0) {
+        const remainder = text.slice(match[0].length).trim();
+        // Simple heuristic: remainder contains something directive-ish
+        if (hasDirectiveWord(remainder, directiveWords)) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+export function setupCorrectionDetector(
+  pi: ExtensionAPI,
+  store: MemoryStore,
+  projectStore: ProjectStoreRef,
+  config: MemoryConfig,
+  dbManager: DatabaseManager | null = null,
+  projectName: ProjectNameRef = null,
+  deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion } = {},
+): void {
+  if (!config.correctionDetection) return;
+
+  let pendingCorrection = false;
+  let turnsSinceLastCorrection = 3; // Start at threshold so first correction can fire immediately
+  let correctionInProgress = false;
+  const runDirect = deps.runDirectMemoryCompletion ?? runDirectMemoryCompletion;
+
+  // Flag on message_end (user role)
+  pi.on("message_end", async (event, _ctx) => {
+    if (event.message.role !== "user") return;
+    const text = getMessageText(event.message);
+    if (!text) return;
+    if (isCorrection(text, config)) {
+      pendingCorrection = true;
+    }
+  });
+
+  // Trigger on turn_end (we need full context: user correction + what agent said)
+  pi.on("turn_end", async (event, ctx) => {
+    if (!pendingCorrection) {
+      turnsSinceLastCorrection++;
+      return;
+    }
+    pendingCorrection = false;
+
+    // Rate limit: max 1 correction save per 3 turns
+    if (turnsSinceLastCorrection < 3) return;
+    if (correctionInProgress) return;
+
+    turnsSinceLastCorrection = 0;
+    correctionInProgress = true;
+
+    try {
+      // Build conversation snapshot
+      const entries = ctx.sessionManager.getBranch();
+      const parts: string[] = [];
+
+      for (const entry of entries) {
+        if (entry.type !== "message") continue;
+        const msg = entry.message;
+        const text = getMessageText(msg);
+        if (!text) continue;
+        const prefix = msg.role === "user" ? "[USER]" : "[ASSISTANT]";
+        parts.push(`${prefix}: ${text}`);
+      }
+
+      // Only include last few exchanges (correction context is recent)
+      const recentParts = parts.slice(-6);
+
+      const activeProjectStore = resolveProjectStore(projectStore);
+      const activeProjectName = resolveProjectName(projectName);
+      const currentMemory = store.getMemoryEntries().join(ENTRY_DELIMITER);
+      const currentUser = store.getUserEntries().join(ENTRY_DELIMITER);
+      const currentProject = activeProjectStore ? activeProjectStore.getMemoryEntries().join(ENTRY_DELIMITER) : null;
+
+      const promptBody = [
+        "--- Current Memory ---",
+        currentMemory || "(empty)",
+        "",
+        "--- Current User Profile ---",
+        currentUser || "(empty)",
+      ];
+
+      if (currentProject !== null) {
+        promptBody.push(
+          "",
+          "--- Current Project Memory ---",
+          currentProject || "(empty)",
+        );
+      }
+
+      promptBody.push(
+        "",
+        "--- Recent Conversation ---",
+        recentParts.join("\n\n"),
+      );
+
+      let savedViaLlm = false;
+
+      const runSubprocessCorrection = async (): Promise<void> => {
+        const subprocessPrompt = [
+          CORRECTION_SAVE_PROMPT,
+          "",
+          buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
+          "",
+          ...promptBody,
+        ].join("\n");
+        const result = await execChildPrompt(pi, subprocessPrompt, config, {
+          cwd: ctx.cwd,
+          model: resolveChildPiModel(ctx.model),
+          signal: ctx.signal,
+          timeoutMs: 30000,
+        });
+        if (result.code === 0 && result.stdout) {
+          const output = result.stdout.trim();
+          savedViaLlm = !!output && !output.toLowerCase().includes("nothing to save");
+        }
+      };
+
+      let handledDirect = false;
+      if (usesDirectTransport(config)) {
+        try {
+          const directResult = await runDirect(
+            ctx,
+            store,
+            activeProjectStore,
+            {
+              systemPrompt: [
+                DIRECT_CORRECTION_SYSTEM_PROMPT,
+                "",
+                buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
+              ].join("\n"),
+              userPrompt: promptBody.join("\n"),
+              config,
+              timeoutMs: 30000,
+              signal: ctx.signal,
+            },
+            dbManager,
+            activeProjectName,
+          );
+          if (directResult.ok) {
+            savedViaLlm = directResult.appliedCount > 0;
+            handledDirect = true;
+          }
+        } catch {
+          // Fall through to subprocess below.
+        }
+      }
+
+      if (!handledDirect) {
+        await runSubprocessCorrection();
+      }
+
+      if (savedViaLlm) {
+        ctx.ui.notify("🔧 Correction detected — memory updated", "info");
+      }
+
+      // Also save as a failure memory for learning
+      try {
+        let lastUserMsg: string | undefined;
+        for (let i = recentParts.length - 1; i >= 0; i--) {
+          if (recentParts[i].startsWith("[USER]")) {
+            lastUserMsg = recentParts[i];
+            break;
+          }
+        }
+        const correctionText = lastUserMsg ? lastUserMsg.replace(/^\[USER\]:\s*/, "") : "";
+        if (correctionText) {
+          const directive = extractCorrectionDirective(correctionText);
+          const failureReason = "User corrected the agent";
+          const scopedProjectName = activeProjectStore ? activeProjectName : null;
+          await store.addFailure(directive, {
+            category: "correction",
+            failureReason,
+            project: scopedProjectName ?? undefined,
+          });
+        }
+      } catch {
+        // Best-effort — don't block the session
+      }
+    } catch {
+      // Best-effort — don't block the session
+    } finally {
+      correctionInProgress = false;
+    }
+  });
+}

package/dist/extensions/pi-hermes-memory/src/handlers/index-sessions.ts

@@ -0,0 +1,86 @@
+/**
+ * Index sessions command — /memory-index-sessions imports past sessions into SQLite.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { DatabaseManager } from '../store/db.js';
+import { indexAllSessions, getSessionStats } from '../store/session-indexer.js';
+import { AGENT_ROOT } from '../paths.js';
+
+const SESSIONS_DIR = process.env.SELESAI_CODING_AGENT_SESSION_DIR
+  || path.join(AGENT_ROOT, 'sessions');
+
+export function registerIndexSessionsCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("memory-index-sessions", {
+    description: "Import past Pi sessions into the search database",
+    handler: async (_args, ctx: ExtensionCommandContext) => {
+      // Show initial progress
+      ctx.ui.notify('🔍 Scanning session directories...', 'info');
+
+      try {
+        // Count sessions first for progress display
+        let totalFiles = 0;
+        let projectDirs: string[] = [];
+        if (fs.existsSync(SESSIONS_DIR)) {
+          projectDirs = fs.readdirSync(SESSIONS_DIR)
+            .filter(d => fs.statSync(path.join(SESSIONS_DIR, d)).isDirectory());
+          for (const dir of projectDirs) {
+            const files = fs.readdirSync(path.join(SESSIONS_DIR, dir))
+              .filter(f => f.endsWith('.jsonl'));
+            totalFiles += files.length;
+          }
+        }
+
+        ctx.ui.notify(`📁 Found ${totalFiles} session files across ${projectDirs.length} projects\n⏳ Indexing...`, 'info');
+
+        const memoryDir = path.join(AGENT_ROOT, 'pi-hermes-memory');
+        const dbManager = new DatabaseManager(memoryDir);
+
+        try {
+          const result = indexAllSessions(dbManager, SESSIONS_DIR);
+          const stats = getSessionStats(dbManager);
+
+          let output = `\n✅ Session indexing complete!\n\n`;
+          output += `📊 Results:\n`;
+          output += `├─ Sessions processed: ${result.sessionsProcessed}\n`;
+          output += `├─ Sessions indexed: ${result.sessionsIndexed}\n`;
+          output += `├─ Sessions skipped (already indexed): ${result.sessionsSkipped}\n`;
+          output += `└─ Messages indexed: ${result.messagesIndexed}\n`;
+
+          if (stats.projects.length > 0) {
+            output += `\n📁 Projects indexed:\n`;
+            for (const p of stats.projects) {
+              output += `├─ ${p.project}: ${p.sessions} sessions, ${p.messages} messages\n`;
+            }
+          }
+
+          // Show totals
+          output += `\n📈 Database totals:\n`;
+          output += `├─ ${stats.totalSessions} sessions\n`;
+          output += `├─ ${stats.totalMessages} messages\n`;
+          output += `└─ ${stats.projects.length} projects\n`;
+
+          if (result.errors.length > 0) {
+            output += `\n⚠️ Errors (${result.errors.length}):\n`;
+            for (const err of result.errors.slice(0, 3)) {
+              output += `├─ ${err}\n`;
+            }
+            if (result.errors.length > 3) {
+              output += `└─ ... and ${result.errors.length - 3} more\n`;
+            }
+          }
+
+          output += `\n💡 Use the session_search tool to search across indexed sessions.`;
+
+          ctx.ui.notify(output, 'info');
+        } finally {
+          dbManager.close();
+        }
+      } catch (err) {
+        ctx.ui.notify(`❌ Session indexing failed: ${err instanceof Error ? err.message : String(err)}`, 'error');
+      }
+    },
+  });
+}

package/dist/extensions/pi-hermes-memory/src/handlers/insights.ts

@@ -0,0 +1,78 @@
+/**
+ * Insights command — /memory-insights shows what's stored in persistent memory.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { MemoryStore } from "../store/memory-store.js";
+import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
+
+export function registerInsightsCommand(pi: ExtensionAPI, store: MemoryStore, projectStore: ProjectStoreRef, projectName: ProjectNameRef): void {
+  pi.registerCommand("memory-insights", {
+    description: "Show what's stored in persistent memory",
+    handler: async (_args, ctx) => {
+      const memoryEntries = store.getMemoryEntries();
+      const userEntries = store.getUserEntries();
+      const activeProjectStore = resolveProjectStore(projectStore);
+      const activeProjectName = resolveProjectName(projectName);
+      const projectEntries = activeProjectStore ? activeProjectStore.getMemoryEntries() : null;
+
+      const lines: string[] = [];
+      lines.push("");
+      lines.push("  ╔══════════════════════════════════════════════╗");
+      lines.push("  ║            🧠 Memory Insights                ║");
+      lines.push("  ╚══════════════════════════════════════════════╝");
+      lines.push("");
+
+      // Memory section
+      lines.push("  📋 MEMORY (your personal notes)");
+      lines.push("  " + "─".repeat(44));
+      if (memoryEntries.length === 0) {
+        lines.push("  (empty)");
+      } else {
+        for (let i = 0; i < memoryEntries.length; i++) {
+          const preview =
+            memoryEntries[i].length > 100
+              ? memoryEntries[i].slice(0, 100) + "..."
+              : memoryEntries[i];
+          lines.push(`  ${i + 1}. ${preview}`);
+        }
+      }
+      lines.push("");
+
+      // User section
+      lines.push("  👤 USER PROFILE");
+      lines.push("  " + "─".repeat(44));
+      if (userEntries.length === 0) {
+        lines.push("  (empty)");
+      } else {
+        for (let i = 0; i < userEntries.length; i++) {
+          const preview =
+            userEntries[i].length > 100
+              ? userEntries[i].slice(0, 100) + "..."
+              : userEntries[i];
+          lines.push(`  ${i + 1}. ${preview}`);
+        }
+      }
+      lines.push("");
+
+      if (projectEntries !== null) {
+        lines.push(`  📁 PROJECT MEMORY: ${activeProjectName ?? ""}`);
+        lines.push("  " + "─".repeat(44));
+        if (projectEntries.length === 0) {
+          lines.push("  (empty)");
+        } else {
+          for (let i = 0; i < projectEntries.length; i++) {
+            const preview =
+              projectEntries[i].length > 100
+                ? projectEntries[i].slice(0, 100) + "..."
+                : projectEntries[i];
+            lines.push(`  ${i + 1}. ${preview}`);
+          }
+        }
+        lines.push("");
+      }
+
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+}

package/dist/extensions/pi-hermes-memory/src/handlers/interview.ts

@@ -0,0 +1,37 @@
+/**
+ * Interview command — /memory-interview guides new users through a brief
+ * onboarding interview to pre-fill their USER.md profile.
+ *
+ * This eliminates the "empty memory cold start" problem where users get
+ * zero value until multiple sessions accumulate facts organically.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { MemoryStore } from "../store/memory-store.js";
+import { INTERVIEW_PROMPT } from "../constants.js";
+
+export function registerInterviewCommand(
+  pi: ExtensionAPI,
+  store: MemoryStore,
+): void {
+  pi.registerCommand("memory-interview", {
+    description: "Answer a few questions to pre-fill your user profile so the agent remembers you across sessions",
+    handler: async (_args, ctx) => {
+      const userEntries = store.getUserEntries();
+
+      if (userEntries.length > 0) {
+        // User already has profile entries — acknowledge and offer choices
+        ctx.ui.notify(
+          `\n  🧠 You already have ${userEntries.length} profile entr${userEntries.length === 1 ? "y" : "ies"}:\n` +
+            userEntries.map((e) => `     • ${e.slice(0, 80)}${e.length > 80 ? "..." : ""}`).join("\n") +
+            "\n\n  Starting the interview will add to or update these.\n",
+          "info",
+        );
+      }
+
+      // Send the interview prompt as a user message to trigger the agent turn
+      await ctx.waitForIdle();
+      pi.sendUserMessage(INTERVIEW_PROMPT);
+    },
+  });
+}