pi-orchestrator-config 4.1.5

package/extensions/orchestrator/session-search.ts

@@ -0,0 +1,243 @@
+/**
+ * Session Search — keyword search over past conversation summaries.
+ *
+ * Indexes compacted conversation summaries into a JSON file with simple
+ * keyword matching. Provides a tool for the LLM to recall past discussions
+ * at zero LLM cost.
+ *
+ * Inspired by Hermes Agent's session search layer.
+ * Uses JSON storage instead of SQLite for portability (no native deps).
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { getProjectDataDir } from "./utils.js";
+
+// ── Storage ────────────────────────────────────────────────────────────────
+
+interface SessionEntry {
+  sessionId: string;
+  timestamp: string;
+  summary: string;
+}
+
+interface SessionStore {
+  entries: SessionEntry[];
+}
+
+function getStorePath(cwd: string): string {
+  return join(getProjectDataDir(cwd), "session-search.json");
+}
+
+function loadStore(cwd: string): SessionStore {
+  const storePath = getStorePath(cwd);
+  if (!existsSync(storePath)) return { entries: [] };
+  try {
+    const raw = JSON.parse(readFileSync(storePath, "utf-8"));
+    if (!raw || typeof raw !== "object" || !Array.isArray(raw.entries)) {
+      console.error("[session-search] corrupt store shape, resetting");
+      return { entries: [] };
+    }
+    // Filter to only valid entries
+    const entries = raw.entries.filter(
+      (e: unknown): e is SessionEntry =>
+        typeof e === "object" && e !== null &&
+        typeof (e as any).sessionId === "string" &&
+        typeof (e as any).timestamp === "string" &&
+        typeof (e as any).summary === "string"
+    );
+    return { entries };
+  } catch (err) {
+    console.error("[session-search] corrupt store, resetting:", err);
+    return { entries: [] };
+  }
+}
+
+function saveStore(cwd: string, store: SessionStore): void {
+  writeFileSync(getStorePath(cwd), JSON.stringify(store, null, 2), "utf-8");
+}
+
+// ── Index a session summary ────────────────────────────────────────────────
+
+export function indexSessionSummary(
+  cwd: string,
+  sessionId: string,
+  summary: string,
+): void {
+  if (!summary || !summary.trim()) return;
+  const store = loadStore(cwd);
+
+  // Avoid duplicate entries for the same session
+  const exists = store.entries.some(
+    (e) => e.sessionId === sessionId && e.summary === summary.trim(),
+  );
+  if (exists) return;
+
+  store.entries.push({
+    sessionId,
+    timestamp: new Date().toISOString(),
+    summary: summary.trim(),
+  });
+
+  // Keep max 500 entries (oldest dropped)
+  if (store.entries.length > 500) {
+    store.entries = store.entries.slice(-500);
+  }
+
+  saveStore(cwd, store);
+}
+
+// ── Search sessions ────────────────────────────────────────────────────────
+
+export interface SearchResult {
+  sessionId: string;
+  timestamp: string;
+  snippet: string;
+  score: number;
+}
+
+export function searchSessions(
+  cwd: string,
+  query: string,
+  limit: number = 10,
+): SearchResult[] {
+  const store = loadStore(cwd);
+  if (store.entries.length === 0) return [];
+
+  const queryWords = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (queryWords.length === 0) return [];
+
+  const results: SearchResult[] = [];
+
+  for (const entry of store.entries) {
+    const summaryLower = entry.summary.toLowerCase();
+
+    // Score: count how many query words match
+    let matchCount = 0;
+    for (const word of queryWords) {
+      if (summaryLower.includes(word)) matchCount++;
+    }
+
+    if (matchCount === 0) continue;
+
+    // Extract snippet around first match
+    const firstWord = queryWords.find((w) => summaryLower.includes(w))!;
+    const matchIdx = summaryLower.indexOf(firstWord);
+    const snippetStart = Math.max(0, matchIdx - 80);
+    const snippetEnd = Math.min(entry.summary.length, matchIdx + 120);
+    let snippet = entry.summary.slice(snippetStart, snippetEnd).trim();
+    if (snippetStart > 0) snippet = "..." + snippet;
+    if (snippetEnd < entry.summary.length) snippet = snippet + "...";
+
+    results.push({
+      sessionId: entry.sessionId,
+      timestamp: entry.timestamp,
+      snippet,
+      score: matchCount / queryWords.length,
+    });
+  }
+
+  // Sort by score (desc), then recency (desc)
+  results.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.timestamp.localeCompare(a.timestamp);
+  });
+
+  return results.slice(0, limit);
+}
+
+
+
+// ── Tool Registration ──────────────────────────────────────────────────────
+
+export function registerSessionSearch(pi: ExtensionAPI): void {
+  // Only register in the orchestrator, not subagents
+  if (process.env.PI_SUBAGENT_CHILD === "1") return;
+
+  pi.registerTool({
+    name: "session_search",
+    label: "Session Search",
+    description:
+      "Search past conversation summaries by keyword. Use when the user references " +
+      "something from a past session, or when you need to recall what was discussed " +
+      "previously. Returns matching snippets from past sessions at zero LLM cost.",
+    parameters: Type.Object({
+      query: Type.String({
+        description: "Search query — keywords or phrases to find in past conversations",
+      }),
+      limit: Type.Optional(
+        Type.Number({
+          description: "Max results to return (default: 10)",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const results = searchSessions(ctx.cwd, params.query, params.limit ?? 10);
+
+      if (results.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `No past sessions found matching "${params.query}".`,
+          }],
+        };
+      }
+
+      const lines = results.map((r) =>
+        `**${r.timestamp.split("T")[0]}** (${r.sessionId.slice(0, 8)})\n${r.snippet}`
+      );
+
+      return {
+        content: [{
+          type: "text",
+          text: `Found ${results.length} past session(s) matching "${params.query}":\n\n${lines.join("\n\n---\n\n")}`,
+        }],
+      };
+    },
+  });
+
+  // Accumulate user messages for session-end indexing
+  let sessionMessages: string[] = [];
+  let sessionCwd = "";
+  let sessionId = "";
+
+  pi.on("session_start", (_event, ctx) => {
+    sessionMessages = [];
+    sessionCwd = ctx.cwd;
+    sessionId = ctx.sessionManager?.getSessionId?.() || `session-${Date.now()}`;
+  });
+
+  pi.on("input", (event, _ctx) => {
+    const text = event?.text;
+    if (!text || text.length < 15) return;
+    // Skip slash commands and system-injected text
+    if (text.startsWith("/") || text.startsWith("[IMPORTANT:") || text.startsWith("[SYSTEM:")) return;
+    sessionMessages.push(text.slice(0, 200));
+  });
+
+  // Index compaction summaries when context is compacted
+  pi.on("session_compact", (event, ctx) => {
+    try {
+      const summary = event?.compactionEntry?.summary;
+      if (!summary || summary.length < 50) return;
+      const cwd = sessionCwd || ctx.cwd;
+      const sid = sessionId || ctx.sessionManager?.getSessionId?.() || `session-${Date.now()}`;
+      indexSessionSummary(cwd, sid, summary);
+    } catch (err) {
+      console.error("[session-search] indexing failed on compact:", err);
+    }
+  });
+
+  // Index accumulated messages on session shutdown
+  pi.on("session_shutdown", () => {
+    try {
+      if (sessionMessages.length < 3 || !sessionCwd) return;
+      const summary = sessionMessages.join(" | ").slice(0, 1000);
+      indexSessionSummary(sessionCwd, sessionId, summary);
+    } catch (err) {
+      console.error("[session-search] indexing failed on shutdown:", err);
+    }
+  });
+}

package/extensions/orchestrator/session-validation.ts

@@ -0,0 +1,374 @@
+/**
+ * Session start validation — checks for required/optional CLI tools.
+ */
+
+import { execSync, execFileSync } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { setUvAvailable, isUvAvailable } from "./enforcement-helpers.js";
+import { checkMinPiVersion } from "./utils.js";
+
+/** Check whether a CLI command is available on PATH. */
+function hasCmd(cmd: string): boolean {
+  try {
+    execSync(`command -v ${cmd}`, {
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Register the /repair command — fixes orphaned tool calls in session files. */
+function registerRepairCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("repair", {
+    description: "Repair session — fix orphaned tool calls that break API requests",
+    handler: async (_args, ctx) => {
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      if (!sessionFile || !fs.existsSync(sessionFile)) {
+        ctx.ui.notify("No session file found", "warning");
+        return;
+      }
+
+      const raw = fs.readFileSync(sessionFile, "utf-8");
+      const lines = raw.split("\n").filter((l) => l.trim());
+
+      // Parse all entries and build index
+      const entries: any[] = [];
+      const byId = new Map<string, any>();
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.id) {
+            entries.push(entry);
+            byId.set(entry.id, entry);
+          }
+        } catch { /* skip malformed lines */ }
+      }
+
+      // Walk active branch (leaf to root) to find orphans on the ACTUAL path
+      // The flat file may have toolResults on dead branches that don't help.
+      const leaf = entries[entries.length - 1];
+      if (!leaf) {
+        ctx.ui.notify("Session file is empty", "warning");
+        return;
+      }
+
+      const branch: any[] = [];
+      let cur = leaf;
+      while (cur) {
+        branch.push(cur);
+        cur = cur.parentId ? byId.get(cur.parentId) : null;
+      }
+      branch.reverse();
+
+      // Collect toolCall IDs and toolResult IDs on the active branch
+      const toolCalls = new Map<string, { parentId: string; toolName: string }>();
+      const toolResults = new Set<string>();
+
+      for (const entry of branch) {
+        const msg = entry.message;
+        if (!msg) continue;
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+          for (const item of msg.content) {
+            if (item.type === "toolCall" && item.id) {
+              toolCalls.set(item.id, {
+                parentId: entry.id,
+                toolName: item.toolName || item.name || "unknown",
+              });
+            }
+          }
+        } else if (msg.role === "toolResult" && msg.toolCallId) {
+          toolResults.add(msg.toolCallId);
+        }
+      }
+
+      // Find orphans on the active branch, and the next branch entry after each orphan parent
+      // so we can re-parent it through the synthetic toolResult.
+      const orphanGroups = new Map<string, {
+        calls: { callId: string; toolName: string }[];
+        nextBranchEntryId: string | null;
+      }>();
+      for (const [callId, meta] of toolCalls) {
+        if (!toolResults.has(callId)) {
+          if (!orphanGroups.has(meta.parentId)) {
+            // Find the next entry on the branch after this parent
+            const idx = branch.findIndex((e) => e.id === meta.parentId);
+            const nextEntry = idx >= 0 && idx + 1 < branch.length ? branch[idx + 1] : null;
+            orphanGroups.set(meta.parentId, {
+              calls: [],
+              nextBranchEntryId: nextEntry?.id ?? null,
+            });
+          }
+          orphanGroups.get(meta.parentId)!.calls.push({ callId, toolName: meta.toolName });
+        }
+      }
+
+      if (orphanGroups.size === 0) {
+        ctx.ui.notify("Session is clean \u2014 no orphaned tool calls found", "info");
+        return;
+      }
+
+      // Build synthetic IDs and re-parent map.
+      // Chain: assistant(parent) -> synthetic_toolResult(s) -> next_entry
+      // The LAST synthetic toolResult becomes the new parent for the next branch entry.
+      const reparentMap = new Map<string, string>(); // entryId -> newParentId
+      const syntheticsByParent = new Map<string, any[]>();
+      let totalFixed = 0;
+      const fixedDetails: string[] = [];
+
+      for (const [parentId, group] of orphanGroups) {
+        const synthetics: any[] = [];
+        let prevId = parentId;
+        for (const call of group.calls) {
+          const synId = crypto.randomBytes(4).toString("hex");
+          synthetics.push({
+            type: "message",
+            id: synId,
+            parentId: prevId,
+            timestamp: new Date().toISOString(),
+            message: {
+              role: "toolResult",
+              toolCallId: call.callId,
+              toolName: call.toolName,
+              content: [{ type: "text", text: "Error: session interrupted \u2014 tool call did not complete" }],
+              isError: true,
+              timestamp: Date.now(),
+            },
+          });
+          prevId = synId;
+          totalFixed++;
+          fixedDetails.push(`  \u2022 ${call.toolName} (${call.callId})`);
+        }
+        syntheticsByParent.set(parentId, synthetics);
+        // Re-parent the next branch entry to point to the last synthetic
+        if (group.nextBranchEntryId) {
+          reparentMap.set(group.nextBranchEntryId, prevId);
+        }
+      }
+
+      // Rewrite the session file:
+      // 1. Insert synthetics after their parent
+      // 2. Re-parent entries that need it
+      const repairedLines: string[] = [];
+      for (const line of lines) {
+        let entry: any;
+        try { entry = JSON.parse(line); } catch {
+          repairedLines.push(line);
+          continue;
+        }
+        // Re-parent if needed
+        if (entry.id && reparentMap.has(entry.id)) {
+          entry.parentId = reparentMap.get(entry.id);
+          repairedLines.push(JSON.stringify(entry));
+        } else {
+          repairedLines.push(line);
+        }
+        // Insert synthetics after parent
+        if (entry.id && syntheticsByParent.has(entry.id)) {
+          for (const syn of syntheticsByParent.get(entry.id)!) {
+            repairedLines.push(JSON.stringify(syn));
+          }
+        }
+      }
+
+      fs.writeFileSync(sessionFile, repairedLines.join("\n") + "\n");
+
+      ctx.ui.notify(
+        `\ud83d\udd27 Repaired ${totalFixed} orphaned tool call${totalFixed > 1 ? "s" : ""}:\n${fixedDetails.join("\n")}\nReloading session...`,
+        "info",
+      );
+
+      // Force session re-read — switchSession to the same file rebuilds the tree
+      await ctx.switchSession(sessionFile);
+    },
+  });
+}
+
+/** Check for required/optional CLI tools and notify the user. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function checkSessionTools(ctx: any): Promise<void> {
+  // ── uv install suggestion (availability already set in session_start) ──
+  if (!isUvAvailable()) {
+    ctx.ui.notify(
+      "⚡ uv is not installed. Install it for better Python support and auto-fix for python/pip commands:\n" +
+      "  • macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh\n" +
+      "  • Windows: powershell -ExecutionPolicy ByPass -c \"irm https://astral.sh/uv/install.ps1 | iex\"\n" +
+      "  • Docs: https://docs.astral.sh/uv/",
+      "warning",
+    );
+  }
+
+  const missing: string[] = [];
+  const optional: string[] = [];
+
+  // Optional
+  if (!hasCmd("gh"))
+    optional.push("gh — GitHub CLI. Install: https://cli.github.com/");
+  if (!hasCmd("mcpl"))
+    optional.push(
+      "mcpl — MCP Launchpad. Install: https://github.com/kenneth-liao/mcp-launchpad",
+    );
+  if (!hasCmd("myk-pi-tools"))
+    optional.push(
+      "myk-pi-tools — PR/release/review CLI. Install: uv tool install git+https://github.com/myk-org/pi-config",
+    );
+
+  // Check agent-browser skill
+  const agentBrowserPaths = [
+    path.join(process.env.HOME || "", ".agents", "skills", "agent-browser", "SKILL.md"),
+    path.join(process.env.HOME || "", ".pi", "agent", "skills", "agent-browser", "SKILL.md"),
+  ];
+  if (!agentBrowserPaths.some((p) => fs.existsSync(p))) {
+    optional.push(
+      "agent-browser skill — browser automation. Install: npx skills add vercel-labs/agent-browser@agent-browser -g -y",
+    );
+  }
+
+  // Check prek only if .pre-commit-config.yaml exists
+  try {
+    if (
+      fs.existsSync(path.join(ctx.cwd, ".pre-commit-config.yaml")) &&
+      !hasCmd("prek")
+    ) {
+      optional.push(
+        "prek — pre-commit wrapper (.pre-commit-config.yaml detected). Install: https://github.com/j178/prek",
+      );
+    }
+  } catch (e: any) { console.debug("[session-validation] tool detection failed:", e?.message || e); }
+
+  if (missing.length > 0 || optional.length > 0) {
+    const parts: string[] = [];
+    if (missing.length > 0)
+      parts.push(
+        `⚠️ CRITICAL missing:\n${missing.map((m) => `  • ${m}`).join("\n")}`,
+      );
+    if (optional.length > 0)
+      parts.push(
+        `Optional missing:\n${optional.map((m) => `  • ${m}`).join("\n")}`,
+      );
+    ctx.ui.notify(
+      parts.join("\n\n"),
+      missing.length > 0 ? "warning" : "info",
+    );
+  }
+}
+
+/** Check for pi-config version upgrades and show changelog notification. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function checkUpgradeChangelog(ctx: any): Promise<void> {
+  // Find pi-config package.json by walking up from this file's directory
+  try {
+    let searchDir = __dirname ?? path.dirname(new URL(import.meta.url).pathname);
+    let currentVersion: string | null = null;
+    for (let i = 0; i < 5; i++) {
+      const candidate = path.join(searchDir, "package.json");
+      if (fs.existsSync(candidate)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+          if (pkg.name === "pi-orchestrator-config" && pkg.version) {
+            currentVersion = pkg.version;
+            break;
+          }
+        } catch (e: any) { console.debug("[session-validation] package.json parse failed:", e?.message || e); }
+      }
+      searchDir = path.dirname(searchDir);
+    }
+    if (currentVersion) {
+      const versionFile = path.join(
+        process.env.HOME || "",
+        ".pi",
+        "pi-config-last-version",
+      );
+      let lastVersion: string | null = null;
+      try {
+        lastVersion = fs.readFileSync(versionFile, "utf-8").trim();
+      } catch (e: any) { console.debug("[session-validation] read last version failed:", e?.message || e); }
+
+      if (!lastVersion) {
+        // First run — just record the version, no notification
+        try {
+          fs.mkdirSync(path.dirname(versionFile), { recursive: true });
+          fs.writeFileSync(versionFile, currentVersion, "utf-8");
+        } catch (e: any) { console.debug("[session-validation] write version file failed:", e?.message || e); }
+      } else if (lastVersion !== currentVersion && hasCmd("gh")) {
+        // Version changed — fetch release notes (5s timeout, no shell)
+        const tag = `v${currentVersion}`;
+        const releaseUrl = `https://github.com/myk-org/pi-config/releases/tag/${tag}`;
+        let notified = false;
+        try {
+          const body = execFileSync(
+            "gh",
+            ["release", "view", "--repo", "myk-org/pi-config", tag, "--json", "body", "--jq", ".body"],
+            { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+          ).toString().trim();
+          if (body) {
+            const maxLen = 1500;
+            const truncated = body.length > maxLen
+              ? body.slice(0, maxLen) + `\n\n... [See full notes](${releaseUrl})`
+              : body;
+            ctx.ui.notify(
+              `🚀 pi-config updated: ${lastVersion} → ${currentVersion}\n\n${truncated}`,
+              "info",
+            );
+            notified = true;
+          }
+        } catch (e: any) { console.debug("[session-validation] release notes fetch failed:", e?.message || e); }
+        // Only update version file after successful notification
+        // so failed attempts retry on next session
+        if (notified) {
+          try {
+            fs.mkdirSync(path.dirname(versionFile), { recursive: true });
+            fs.writeFileSync(versionFile, currentVersion, "utf-8");
+          } catch (e: any) { console.debug("[session-validation] write version after notify failed:", e?.message || e); }
+        }
+      }
+    }
+  } catch (e: any) { console.debug("[session-validation] upgrade changelog failed:", e?.message || e); }
+}
+
+export function registerSessionValidation(pi: ExtensionAPI): void {
+  registerRepairCommand(pi);
+
+  pi.on("session_start", async (_event, ctx) => {
+    // Always check uv availability — even in headless mode.
+    // Enforcement depends on this being set correctly.
+    try {
+      const uvInstalled = hasCmd("uv");
+      setUvAvailable(uvInstalled);
+    } catch (e: any) {
+      console.debug("[session-validation] uv check failed:", e?.message || e);
+    }
+
+    if (!ctx.hasUI) return;
+
+    // Check minimum pi version
+    const versionCheck = checkMinPiVersion();
+    if (!versionCheck.ok) {
+      if (versionCheck.installed === null) {
+        ctx.ui.notify(
+          `⚠️ pi version could not be determined; CLI/ACPX providers require >= ${versionCheck.required} ` +
+            `and will still be attempted. Some features (--session-id for async agents, session_info_changed events) ` +
+            `may not work. Update pi if registration fails: npm install -g @earendil-works/pi-coding-agent`,
+          "warning",
+        );
+      } else {
+        ctx.ui.notify(
+          `⚠️ pi ${versionCheck.installed} is below minimum required version ${versionCheck.required}. ` +
+            `CLI/ACPX providers (createProvider) are disabled, and some features (--session-id for async agents, session_info_changed events) will not work. ` +
+            `Update pi: npm install -g @earendil-works/pi-coding-agent`,
+          "warning",
+        );
+      }
+    }
+
+    await checkSessionTools(ctx);
+
+    // ── Upgrade changelog ──────────────────────────────────────────────
+    await checkUpgradeChangelog(ctx);
+  });
+}