pan-wizard 2.9.1 → 3.4.1

package/hooks/dist/pan-statusline.js

@@ -1,108 +1,154 @@
-#!/usr/bin/env node
-// Claude Code Statusline - PAN Edition
-// Shows: model | current task | directory | context usage
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Read JSON from stdin
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(input);
-    const model = data.model?.display_name || 'Claude';
-    const dir = data.workspace?.current_dir || process.cwd();
-    const session = data.session_id || '';
-    const remaining = data.context_window?.remaining_percentage;
-
-    // Context window display (shows USED percentage scaled to 80% limit)
-    // Claude Code enforces an 80% context limit, so we scale to show 100% at that point
-    let ctx = '';
-    if (remaining != null) {
-      const rem = Math.round(remaining);
-      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
-      // Scale: 80% real usage = 100% displayed
-      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
-
-      // Write context metrics to bridge file for the context-monitor PostToolUse hook.
-      // The monitor reads this file to inject agent-facing warnings when context is low.
-      if (session) {
-        try {
-          const bridgePath = path.join(os.tmpdir(), `claude-ctx-${session}.json`);
-          const bridgeData = JSON.stringify({
-            session_id: session,
-            remaining_percentage: remaining,
-            used_pct: used,
-            timestamp: Math.floor(Date.now() / 1000)
-          });
-          fs.writeFileSync(bridgePath, bridgeData);
-        } catch (e) {
-          // Silent fail -- bridge is best-effort, don't break statusline
-        }
-      }
-
-      // Build progress bar (10 segments)
-      const filled = Math.floor(used / 10);
-      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
-
-      // Color based on scaled usage (thresholds adjusted for new scale)
-      if (used < 63) {        // ~50% real
-        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
-      } else if (used < 81) { // ~65% real
-        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
-      } else if (used < 95) { // ~76% real
-        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
-      } else {
-        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
-      }
-    }
-
-    // Current task from todos
-    let task = '';
-    const homeDir = os.homedir();
-    const todosDir = path.join(homeDir, '.claude', 'todos');
-    if (session && fs.existsSync(todosDir)) {
-      try {
-        const files = fs.readdirSync(todosDir)
-          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
-          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
-          .sort((a, b) => b.mtime - a.mtime);
-
-        if (files.length > 0) {
-          try {
-            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
-            const inProgress = todos.find(t => t.status === 'in_progress');
-            if (inProgress) task = inProgress.activeForm || '';
-          } catch (e) {}
-        }
-      } catch (e) {
-        // Silently fail on file system errors - don't break statusline
-      }
-    }
-
-    // PAN update available?
-    let panUpdate = '';
-    const cacheFile = path.join(homeDir, '.claude', 'cache', 'pan-update-check.json');
-    if (fs.existsSync(cacheFile)) {
-      try {
-        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
-        if (cache.update_available) {
-          panUpdate = '\x1b[33m⬆ /pan:update\x1b[0m │ ';
-        }
-      } catch (e) {}
-    }
-
-    // Output
-    const dirname = path.basename(dir);
-    if (task) {
-      process.stdout.write(`${panUpdate}\x1b[2m${model}\x1b[0m │ \x1b[1m${task}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
-    } else {
-      process.stdout.write(`${panUpdate}\x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
-    }
-  } catch (e) {
-    // Silent fail - don't break statusline on parse errors
-  }
-});
+#!/usr/bin/env node
+// Claude Code Statusline - PAN Edition
+// Shows: model | current task | directory | context | cache | thinking
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Build the statusline output string from the JSON payload Claude Code pipes
+ * to stdin. Pure function — no stdin, no stdout, no process exit. Safe to
+ * call from tests.
+ *
+ * @param {Object} data - Parsed stdin JSON from Claude Code.
+ * @param {Object} [deps] - Optional dep injection for testing.
+ *   {fs, path, homeDir, tmpDir} — defaults to real modules + OS paths.
+ * @returns {string} The statusline content.
+ */
+function buildStatuslineOutput(data, deps) {
+  const d = deps || {};
+  const fsMod = d.fs || fs;
+  const pathMod = d.path || path;
+  const homeDir = d.homeDir || os.homedir();
+  const tmpDir = d.tmpDir || os.tmpdir();
+
+  if (!data || typeof data !== 'object') return '';
+
+  const model = data.model?.display_name || 'Claude';
+  const dir = data.workspace?.current_dir || process.cwd();
+  const session = data.session_id || '';
+  const remaining = data.context_window?.remaining_percentage;
+
+  // Context window bar — shows USED percentage scaled so 80% real = 100% shown.
+  let ctx = '';
+  if (remaining != null) {
+    const rem = Math.round(remaining);
+    const rawUsed = Math.max(0, Math.min(100, 100 - rem));
+    const used = Math.min(100, Math.round((rawUsed / 80) * 100));
+
+    if (session && d.skipBridge !== true) {
+      try {
+        const bridgePath = pathMod.join(tmpDir, `claude-ctx-${session}.json`);
+        fsMod.writeFileSync(bridgePath, JSON.stringify({
+          session_id: session,
+          remaining_percentage: remaining,
+          used_pct: used,
+          timestamp: Math.floor(Date.now() / 1000),
+        }));
+      } catch { /* bridge is best-effort */ }
+    }
+
+    const filled = Math.floor(used / 10);
+    const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+    if (used < 63) {
+      ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+    } else if (used < 81) {
+      ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+    } else if (used < 95) {
+      ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+    } else {
+      ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+    }
+  }
+
+  // E-8: Opus 4.7 indicators. Read from stdin data first (if present),
+  // else merge from optional bridge file `claude-pan-<session>.json` that
+  // an agent or external process can write.
+  let panExtras = null;
+  if (session) {
+    try {
+      const extrasPath = pathMod.join(tmpDir, `claude-pan-${session}.json`);
+      const extrasRaw = fsMod.readFileSync(extrasPath, 'utf8');
+      panExtras = JSON.parse(extrasRaw);
+    } catch { /* no extras is fine */ }
+  }
+
+  const thinkingActive = (data.thinking && data.thinking.active === true)
+    || (panExtras && panExtras.thinking_active === true);
+  const cacheHitRate = (data.cache && typeof data.cache.hit_rate_pct === 'number')
+    ? data.cache.hit_rate_pct
+    : (panExtras && typeof panExtras.cache_hit_rate_pct === 'number'
+      ? panExtras.cache_hit_rate_pct
+      : null);
+
+  let thinkingBadge = '';
+  if (thinkingActive) thinkingBadge = ' \x1b[35m🧠\x1b[0m';
+
+  let cacheBadge = '';
+  if (cacheHitRate != null) {
+    const pct = Math.max(0, Math.min(100, Math.round(cacheHitRate)));
+    // Color: green ≥70%, yellow 30-70%, dim <30% (warmup).
+    const color = pct >= 70 ? '\x1b[32m' : pct >= 30 ? '\x1b[33m' : '\x1b[2m';
+    cacheBadge = ` ${color}⚡${pct}%\x1b[0m`;
+  }
+
+  // Current task from todos
+  let task = '';
+  const todosDir = pathMod.join(homeDir, '.claude', 'todos');
+  let todosExists = false;
+  try { todosExists = fsMod.statSync(todosDir).isDirectory(); } catch { /* missing */ }
+  if (session && todosExists) {
+    try {
+      const files = fsMod.readdirSync(todosDir)
+        .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+        .map(f => {
+          try { return { name: f, mtime: fsMod.statSync(pathMod.join(todosDir, f)).mtime }; }
+          catch { return null; }
+        })
+        .filter(Boolean)
+        .sort((a, b) => b.mtime - a.mtime);
+
+      if (files.length > 0) {
+        try {
+          const todos = JSON.parse(fsMod.readFileSync(pathMod.join(todosDir, files[0].name), 'utf8'));
+          const inProgress = todos.find(t => t.status === 'in_progress');
+          if (inProgress) task = inProgress.activeForm || '';
+        } catch { /* malformed todos file — skip */ }
+      }
+    } catch { /* fs errors — silent */ }
+  }
+
+  // PAN update available?
+  let panUpdate = '';
+  const cacheFile = pathMod.join(homeDir, '.claude', 'cache', 'pan-update-check.json');
+  try {
+    const cache = JSON.parse(fsMod.readFileSync(cacheFile, 'utf8'));
+    if (cache.update_available) panUpdate = '\x1b[33m⬆ /pan:update\x1b[0m │ ';
+  } catch { /* no update cache — silent */ }
+
+  const dirname = pathMod.basename(dir);
+  const head = `${panUpdate}\x1b[2m${model}\x1b[0m`;
+  const taskSegment = task ? ` │ \x1b[1m${task}\x1b[0m` : '';
+  const dirSegment = ` │ \x1b[2m${dirname}\x1b[0m`;
+  return `${head}${taskSegment}${dirSegment}${ctx}${cacheBadge}${thinkingBadge}`;
+}
+
+// ─── Stdin driver ───────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input);
+      process.stdout.write(buildStatuslineOutput(data));
+    } catch {
+      // Silent fail — don't break statusline on parse errors.
+    }
+  });
+}
+
+module.exports = { buildStatuslineOutput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pan-wizard",
-  "version": "2.9.1",
+  "version": "3.4.1",
   "description": "A lightweight workflow automation and context engineering system for Claude Code, OpenCode, Gemini CLI, Codex, and Copilot CLI.",
   "bin": {
     "pan-wizard": "bin/install.js"

package/pan-wizard-core/bin/lib/bridge.cjs

@@ -0,0 +1,269 @@
+/**
+ * Bridge — MCP tool discovery + per-phase recommendation (Spec B v2 Y-5, v3.3).
+ *
+ * Discovery-only scope. We discover what MCP tools are reachable from the
+ * host runtime and what their shapes look like, then recommend which tools
+ * a given phase plan might use. We do NOT auto-inject tools into plans or
+ * auto-invoke them — those belong to a future wave once MCP schemas stabilize.
+ *
+ * Data lives at `.planning/bridge/available-tools.json`:
+ *   {
+ *     cached_at: "2026-04-18T...",
+ *     runtime: "claude",
+ *     servers: [
+ *       {
+ *         name: "linear",
+ *         version: "1.2.3",
+ *         tools: [
+ *           { name: "linear.updateTicket", description: "...", schema: {...} },
+ *           ...
+ *         ]
+ *       },
+ *       ...
+ *     ]
+ *   }
+ *
+ * Populating this file is the host runtime's responsibility (Claude Code's
+ * MCP list API, etc.). This module reads the cache and reasons over it.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error, safeReadFile, toPosix, findPhaseInternal } = require('./core.cjs');
+const { PLANNING_DIR } = require('./constants.cjs');
+const { planningPath } = require('./utils.cjs');
+
+const BRIDGE_DIR = 'bridge';
+const TOOLS_FILE = 'available-tools.json';
+
+function bridgeDir(cwd) {
+  return path.join(planningPath(cwd), BRIDGE_DIR);
+}
+
+function toolsCacheFile(cwd) {
+  return path.join(bridgeDir(cwd), TOOLS_FILE);
+}
+
+/**
+ * Load the cached tool list. Returns an empty catalog if the cache is
+ * missing or malformed.
+ *
+ * @param {string} cwd - Project root
+ * @returns {{cached_at: string|null, runtime: string|null, servers: Array, source: 'cache'|'empty'}}
+ */
+function loadToolCache(cwd) {
+  const raw = safeReadFile(toolsCacheFile(cwd));
+  if (!raw) return { cached_at: null, runtime: null, servers: [], source: 'empty' };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      cached_at: parsed.cached_at || null,
+      runtime: parsed.runtime || null,
+      servers: Array.isArray(parsed.servers) ? parsed.servers : [],
+      source: 'cache',
+    };
+  } catch {
+    return { cached_at: null, runtime: null, servers: [], source: 'empty' };
+  }
+}
+
+/**
+ * Write the tool cache. Used by the command when the host runtime provides
+ * a fresh tool list (or by tests for fixture setup).
+ *
+ * @param {string} cwd - Project root
+ * @param {{runtime, servers}} data
+ * @returns {{written: true, file: string}|{error: string}}
+ */
+function writeToolCache(cwd, data) {
+  if (!data || typeof data !== 'object') return { error: 'data required' };
+  try {
+    fs.mkdirSync(bridgeDir(cwd), { recursive: true });
+  } catch (e) {
+    return { error: `Failed to create bridge dir: ${e.message}` };
+  }
+  const payload = {
+    cached_at: new Date().toISOString(),
+    runtime: data.runtime || null,
+    servers: Array.isArray(data.servers) ? data.servers : [],
+  };
+  const file = toolsCacheFile(cwd);
+  try {
+    fs.writeFileSync(file, JSON.stringify(payload, null, 2), 'utf-8');
+  } catch (e) {
+    return { error: `Failed to write ${file}: ${e.message}` };
+  }
+  return { written: true, file: toPosix(path.relative(cwd, file)) };
+}
+
+/**
+ * Flatten server → tool hierarchy into a single list for easier reasoning.
+ *
+ * @param {Array} servers - From loadToolCache().servers
+ * @returns {Array<{server, name, description, schema}>}
+ */
+function flattenTools(servers) {
+  const tools = [];
+  for (const server of servers || []) {
+    if (!server || !Array.isArray(server.tools)) continue;
+    for (const tool of server.tools) {
+      if (!tool || !tool.name) continue;
+      tools.push({
+        server: server.name,
+        name: tool.name,
+        description: tool.description || '',
+        schema: tool.schema || null,
+      });
+    }
+  }
+  return tools;
+}
+
+/**
+ * List all available MCP tools, flattened.
+ *
+ * @param {string} cwd - Project root
+ * @returns {Object}
+ */
+function listTools(cwd) {
+  const cache = loadToolCache(cwd);
+  const tools = flattenTools(cache.servers);
+  return {
+    cached_at: cache.cached_at,
+    runtime: cache.runtime,
+    server_count: cache.servers.length,
+    tool_count: tools.length,
+    tools,
+    source: cache.source,
+  };
+}
+
+// ─── Recommendation scoring ────────────────────────────────────────────────
+
+/**
+ * Score a tool's relevance to a phase by matching plan keywords against
+ * tool name + description. Naive frequency-based scoring (no embeddings).
+ *
+ * @param {string} phaseText - Combined plan text
+ * @param {{server, name, description}} tool
+ * @returns {{score: number, hits: Array<string>}}
+ */
+function scoreToolForPhase(phaseText, tool) {
+  if (!phaseText || !tool) return { score: 0, hits: [] };
+  const body = phaseText.toLowerCase();
+  const haystack = `${tool.server || ''} ${tool.name || ''} ${tool.description || ''}`.toLowerCase();
+
+  // Extract keywords from the tool's identity: split on non-word chars, dedupe, keep ≥3 chars.
+  const keywords = [...new Set(haystack.split(/\W+/).filter(w => w.length >= 3))];
+
+  let score = 0;
+  const hits = [];
+  for (const kw of keywords) {
+    const re = new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
+    const count = (body.match(re) || []).length;
+    if (count > 0) {
+      score += count;
+      hits.push(kw);
+    }
+  }
+  return { score, hits };
+}
+
+/**
+ * Recommend MCP tools for a specific phase based on plan text keyword match.
+ *
+ * @param {string} cwd - Project root
+ * @param {string|number} phaseNum - Phase identifier
+ * @param {Object} [opts] - {max_recommendations, min_score}
+ * @returns {Object}
+ */
+function recommendForPhase(cwd, phaseNum, opts) {
+  const cache = loadToolCache(cwd);
+  const tools = flattenTools(cache.servers);
+  if (tools.length === 0) {
+    return {
+      phase: String(phaseNum),
+      runtime: cache.runtime,
+      recommendations: [],
+      reason: 'no MCP tools cached — run `pan-tools bridge cache` or ensure host runtime populates .planning/bridge/available-tools.json',
+    };
+  }
+
+  const phaseInfo = findPhaseInternal(cwd, phaseNum);
+  if (!phaseInfo || !phaseInfo.found) {
+    return {
+      phase: String(phaseNum),
+      error: `Phase ${phaseNum} not found in .planning/phases/`,
+    };
+  }
+
+  const phaseDir = path.join(cwd, phaseInfo.directory);
+  const planTexts = (phaseInfo.plans || [])
+    .map(f => safeReadFile(path.join(phaseDir, f)) || '')
+    .join('\n');
+
+  const max = Math.max(1, Math.min(50, Number(opts?.max_recommendations) || 10));
+  const minScore = Math.max(0, Number(opts?.min_score) || 1);
+
+  const scored = tools
+    .map(tool => ({
+      ...tool,
+      ...scoreToolForPhase(planTexts, tool),
+    }))
+    .filter(t => t.score >= minScore)
+    .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+    .slice(0, max);
+
+  return {
+    phase: String(phaseNum),
+    phase_name: phaseInfo.name || null,
+    runtime: cache.runtime,
+    total_candidates: tools.length,
+    recommendations: scored.map(t => ({
+      server: t.server,
+      name: t.name,
+      description: t.description,
+      score: t.score,
+      hits: t.hits,
+    })),
+  };
+}
+
+// ─── CLI wrappers ───────────────────────────────────────────────────────────
+
+function cmdBridgeList(cwd, raw) {
+  output(listTools(cwd), raw);
+}
+
+function cmdBridgeRecommend(cwd, phaseNum, opts, raw) {
+  if (!phaseNum) error('Usage: bridge recommend <phase> [--max N] [--min-score N]');
+  output(recommendForPhase(cwd, phaseNum, opts), raw);
+}
+
+function cmdBridgeCache(cwd, serversJson, runtime, raw) {
+  // For scripted cache writes. Normally the host runtime writes the file,
+  // but this CLI path lets users seed it for testing or from external scripts.
+  if (!serversJson) {
+    // No payload — just echo the current cache path/state.
+    output(listTools(cwd), raw);
+    return;
+  }
+  let servers;
+  try { servers = JSON.parse(serversJson); }
+  catch (e) { error(`Invalid --servers JSON: ${e.message}`); }
+  output(writeToolCache(cwd, { runtime, servers }), raw);
+}
+
+module.exports = {
+  loadToolCache,
+  writeToolCache,
+  flattenTools,
+  listTools,
+  scoreToolForPhase,
+  recommendForPhase,
+  cmdBridgeList,
+  cmdBridgeRecommend,
+  cmdBridgeCache,
+  BRIDGE_DIR,
+  TOOLS_FILE,
+};