jeo-code 0.1.0 → 0.4.5

package/src/commands/setup.ts

@@ -1,5 +1,7 @@
+import { qualifyModelId } from "../ai/model-manager";
+import type { ProviderName } from "../ai/types";
 import { createInterface } from "node:readline/promises";
-import { saveGlobalConfig, readGlobalConfig, type Config } from "../agent/state";
+import { saveGlobalConfig, readGlobalConfig, readRawGlobalConfig, type Config } from "../agent/state";
 import {
   interactiveLogin,
   getStoredOAuth,
@@ -24,7 +26,7 @@ function reportModelChoice(r: { warning?: string; suggestions: string[] }): void
 type ProviderChoice = "anthropic" | "openai" | "gemini" | "ollama" | "lmstudio" | "openai-compatible";
 
 const DEFAULT_MODELS: Record<ProviderChoice, string> = {
-  anthropic: "claude-3-5-sonnet-20241022",
+  anthropic: "claude-sonnet-4-5",
   openai: "gpt-4o",
   gemini: "gemini-2.0-flash",
   ollama: "ollama/llama3.1:8b",
@@ -64,10 +66,20 @@ async function listOpenAiCompatibleModels(baseUrl: string, apiKey?: string): Pro
 }
 
 export async function runSetupCommand(): Promise<void> {
+  // `setup` is interactive; on a non-TTY (piped/CI) stdin readline can't prompt and
+  // would reject with a cryptic "readline was closed". Fail with clear guidance instead.
+  if (!process.stdin.isTTY) {
+    console.log(
+      "jeo setup needs an interactive terminal (TTY).\n" +
+      "Non-interactive options: set env vars (ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY, JEO_DEFAULT_MODEL, OLLAMA_HOST),\n" +
+      "run 'jeo auth login <anthropic|openai|gemini|antigravity>' for OAuth, or edit ~/.jeo/config.json directly. Verify with 'jeo doctor'.",
+    );
+    return;
+  }
   const current = await readGlobalConfig();
   const rl = createInterface({ input: process.stdin, output: process.stdout });
 
-  console.log("\n=== @jeo-code CLI Configuration (joc setup) ===");
+  console.log("\n=== @jeo-code CLI Configuration (jeo setup) ===");
   console.log("Configure providers, API keys / OAuth tokens, and default model.\n");
 
   console.log("Available provider types:");
@@ -87,7 +99,11 @@ export async function runSetupCommand(): Promise<void> {
   };
   const choice = map[sel] ?? "skip";
 
-  const next: Config = JSON.parse(JSON.stringify(current)) as Config;
+  // Build the persisted config from the RAW on-disk state (NOT the env-overlaid
+  // `current`), so `jeo setup` never bakes env-only values — OAuth bearer tokens
+  // (*_OAUTH_TOKEN), JEO_DEFAULT_MODEL, JEO_*_MODEL roles, OLLAMA_HOST/OPENAI_BASE_URL —
+  // permanently into ~/.jeo/config.json. `current` is still used for display defaults.
+  const next: Config = JSON.parse(JSON.stringify(await readRawGlobalConfig())) as Config;
   next.providers = next.providers || {};
   next.oauth = next.oauth || {};
 
@@ -104,7 +120,12 @@ export async function runSetupCommand(): Promise<void> {
     } else {
       const flow = OAUTH_FLOW_REGISTRY[choice as AuthProvider];
       if (!flow.verifiedEndToEnd && flow.note) console.log(`Note: ${flow.note}`);
+      // Abort the pending "Paste redirect URL…" question once the flow settles —
+      // otherwise it survives the SUCCESS/FAILED result, reprints its prompt, and
+      // QUEUES IN FRONT of the API-key fallback question below (setup looked hung).
+      const ac = new AbortController();
       const ctrl: OAuthController = {
+        signal: ac.signal,
         onAuth: ({ url, instructions }) => {
           console.log(`Opening browser:\n  ${url}\n`);
           if (instructions) console.log(instructions + "\n");
@@ -112,10 +133,17 @@ export async function runSetupCommand(): Promise<void> {
         },
         onProgress: msg => console.log(`  … ${msg}`),
         onManualCodeInput: async () =>
-          (await rl.question("Paste redirect URL or code (or wait for the browser callback): ")).trim(),
+          (await rl.question("Paste redirect URL or code (or wait for the browser callback): ", { signal: ac.signal })).trim(),
       };
       try {
-        const { email } = await interactiveLogin(choice as AuthProvider, ctrl);
+        let email: string | undefined;
+        try {
+          ({ email } = await interactiveLogin(choice as AuthProvider, ctrl));
+        } finally {
+          // Must fire BEFORE the catch's API-key question below, or that
+          // question queues behind the stale paste prompt.
+          ac.abort();
+        }
         const stored = await getStoredOAuth(choice as AuthProvider);
         if (stored) next.oauth[choice] = stored;
         console.log(`[SUCCESS] OAuth login complete for ${choice}${email ? ` (${email})` : ""}.`);
@@ -126,12 +154,17 @@ export async function runSetupCommand(): Promise<void> {
         if (key.trim()) next.providers[choice] = key.trim();
       }
     }
-    console.log(`\nRecommended ${choice} models:`);
-    for (const m of recommendedModelsFor(choice)) console.log(`  - ${m}`);
-    const dm = await rl.question(`Default model for ${choice} [${recommendedModelsFor(choice)[0]?.split(" ")[0] ?? DEFAULT_MODELS[choice]}]: `);
-    const picked = chooseDefaultModel(dm, choice);
+    const openAiCodexOnly = choice === "openai" && !!next.oauth.openai && !next.providers.openai;
+    const recommended = recommendedModelsFor(choice, 5, { codex: openAiCodexOnly });
+    const fallbackModel = recommended[0]?.split(" ")[0] ?? DEFAULT_MODELS[choice];
+    console.log(`\nRecommended ${choice}${openAiCodexOnly ? " Codex OAuth" : ""} models:`);
+    for (const m of recommended) console.log(`  - ${m}`);
+    const dm = await rl.question(`Default model for ${choice} [${fallbackModel}]: `);
+    const rawInput = dm.trim();
+    const qualified = rawInput ? qualifyModelId(rawInput, choice as ProviderName) : fallbackModel;
+    const picked = chooseDefaultModel(qualified, choice as ProviderName);
     reportModelChoice(picked);
-    next.defaultModel = picked.model || DEFAULT_MODELS[choice];
+    next.defaultModel = picked.model || fallbackModel;
   } else if (choice === "ollama") {
     const url = await rl.question(`Ollama base URL [${current.ollamaBaseUrl || DEFAULT_BASE_URLS.ollama}]: `);
     next.ollamaBaseUrl = normalizeBaseUrl(url, current.ollamaBaseUrl || DEFAULT_BASE_URLS.ollama!);
@@ -141,11 +174,15 @@ export async function runSetupCommand(): Promise<void> {
       console.log("Detected local Ollama models:");
       models.slice(0, 20).forEach((m, i) => console.log(`  - ${m}`));
       const def = await rl.question(`Default model (ollama/<name>) [${"ollama/" + (models[0] ?? "llama3.1:8b")}]: `);
-      next.defaultModel = def.trim() || `ollama/${models[0] ?? "llama3.1:8b"}`;
+      const rawInput = def.trim();
+      const qualified = rawInput ? qualifyModelId(rawInput, "ollama") : `ollama/${models[0] ?? "llama3.1:8b"}`;
+      next.defaultModel = qualified;
       reportModelChoice(chooseDefaultModel(next.defaultModel, "ollama"));
     } else {
       console.log("  (no models detected — Ollama not reachable, defaulting to llama3.1:8b)");
-      const picked = chooseDefaultModel(await rl.question(`Default model [${DEFAULT_MODELS.ollama}]: `), "ollama");
+      const rawInput = (await rl.question(`Default model [${DEFAULT_MODELS.ollama}]: `)).trim();
+      const qualified = rawInput ? qualifyModelId(rawInput, "ollama") : DEFAULT_MODELS.ollama;
+      const picked = chooseDefaultModel(qualified, "ollama");
       reportModelChoice(picked);
       next.defaultModel = picked.model || DEFAULT_MODELS.ollama;
     }
@@ -163,11 +200,15 @@ export async function runSetupCommand(): Promise<void> {
       console.log("Detected models:");
       models.slice(0, 20).forEach(m => console.log(`  - ${m}`));
       const def = await rl.question(`Default model (openai/<name>) [openai/${models[0]}]: `);
-      next.defaultModel = def.trim() || `openai/${models[0]}`;
+      const rawInput = def.trim();
+      const qualified = rawInput ? qualifyModelId(rawInput, "openai") : `openai/${models[0]}`;
+      next.defaultModel = qualified;
       reportModelChoice(chooseDefaultModel(next.defaultModel, "openai"));
     } else {
       console.log("  (no models detected — endpoint not reachable yet)");
-      const picked = chooseDefaultModel(await rl.question(`Default model [${DEFAULT_MODELS[choice]}]: `), "openai");
+      const rawInput = (await rl.question(`Default model [${DEFAULT_MODELS[choice]}]: `)).trim();
+      const qualified = rawInput ? qualifyModelId(rawInput, "openai") : DEFAULT_MODELS[choice];
+      const picked = chooseDefaultModel(qualified, "openai");
       reportModelChoice(picked);
       next.defaultModel = picked.model || DEFAULT_MODELS[choice];
     }
@@ -184,7 +225,7 @@ export async function runSetupCommand(): Promise<void> {
   if (next.oauth && !next.oauth.anthropic && !next.oauth.openai && !next.oauth.gemini) delete next.oauth;
 
   await saveGlobalConfig(next);
-  console.log("\n[SUCCESS] Configuration saved to ~/.joc/config.json");
+  console.log("\n[SUCCESS] Configuration saved to ~/.jeo/config.json");
   for (const line of buildSetupSummary(next)) console.log(line);
   console.log("");
 }

package/src/commands/skills.ts

@@ -1,38 +1,98 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { SKILLS, getSkill, formatSkill, skillNames } from "../skills/catalog";
-import { getLocalJocDir } from "../agent/state";
+import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs } from "../skills/catalog";
+import { getLocalJeoDir } from "../agent/state";
+
+function editDistance(a: string, b: string): number {
+  const m = a.length, n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const d = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) d[i][0] = i;
+  for (let j = 0; j <= n; j++) d[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1, // deletion
+        d[i][j - 1] + 1, // insertion
+        d[i - 1][j - 1] + cost // substitution
+      );
+    }
+  }
+  return d[m][n];
+}
+
+function suggestSkills(name: string, known: string[]): string[] {
+  const q = name.toLowerCase();
+  if (!q) return [];
+  return known.filter(n => n.toLowerCase().startsWith(q) || editDistance(n.toLowerCase(), q) <= 2);
+}
 
 export async function runSkillsCommand(args: string[] = []): Promise<void> {
-  // `joc skills --write [dir]` materializes bundled skill docs to disk (gjc-style SKILL.md files).
-  if (args[0] === "--write") {
-    const cwd = process.cwd();
-    const dir = args[1] ? path.resolve(cwd, args[1]) : path.join(getLocalJocDir(cwd), "skills");
+  const cwd = process.cwd();
+  const isJson = args.includes("--json");
+  const cleanArgs = args.filter(a => a !== "--json");
+
+  // `jeo skills --write [dir]` materializes bundled skill docs to disk (gjc-style SKILL.md files).
+  if (cleanArgs[0] === "--write") {
+    const dir = cleanArgs[1] ? path.resolve(cwd, cleanArgs[1]) : path.join(getLocalJeoDir(cwd), "skills");
     await fs.mkdir(dir, { recursive: true });
     for (const s of SKILLS) {
       const file = path.join(dir, `${s.name}.md`);
-      await fs.writeFile(file, `# ${s.name}\n\n${formatSkill(s)}\n`, "utf-8");
+      await fs.writeFile(file, s.raw || `# ${s.name}\n\n${formatSkill(s)}\n`, "utf-8");
     }
     console.log(`Wrote ${SKILLS.length} skill docs to ${dir}`);
     return;
   }
 
-  const name = args[0];
-  if (name) {
-    const skill = getSkill(name);
-    if (!skill) {
-      console.log(`Unknown skill: ${name}\nAvailable: ${skillNames().join(", ")}`);
+  // List/lookup over the MERGED set (bundled + ~/.jeo/skills + ~/.agents/skills + project dirs), matching the REPL /skill.
+  const skills = await loadSkills(cwd);
+  const command = cleanArgs[0];
+
+  if (!command || command === "list") {
+    if (isJson) {
+      console.log(JSON.stringify(skills.map(s => ({ name: s.name, summary: s.summary })), null, 2));
+    } else {
+      console.log("\n=== jeo skills ===");
+      console.log("Workflow skills (bundled + ~/.jeo/skills, ~/.agents/skills, project dirs) — 'jeo skills <name>' for details, --write to export:\n");
+      for (const s of skills) {
+        console.log(`  ${s.name.padEnd(16)} ${s.summary}`);
+      }
+      console.log("\nInvoke: /skill <name> [intent]  ·  $<name> [intent]  ·  skill-owned slash aliases (e.g. /speckit.plan)");
+      console.log("Discovery dirs (later wins on name clash; JEO_SKILLS_DIR adds more):");
+      for (const d of skillDirs(cwd)) console.log(`  ${d}`);
+      console.log("");
+    }
+    return;
+  }
+
+  let name: string;
+  if (command === "read") {
+    name = cleanArgs[1];
+    if (!name) {
+      console.log("Error: Missing skill name for 'read' command.");
       process.exitCode = 1;
       return;
     }
-    console.log(formatSkill(skill));
+  } else {
+    name = command;
+  }
+
+  const skill = getSkillFrom(skills, name);
+  if (!skill) {
+    const knownNames = skills.map(s => s.name);
+    const suggestions = suggestSkills(name, knownNames);
+    const hint = suggestions.length ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+    console.log(`Unknown skill: ${name}.${hint}\nAvailable: ${knownNames.join(", ")}`);
+    process.exitCode = 1;
     return;
   }
 
-  console.log("\n=== joc skills ===");
-  console.log("Bundled workflow skills (run 'joc skills <name>' for details, --write to export):\n");
-  for (const s of SKILLS) {
-    console.log(`  ${s.name.padEnd(16)} ${s.summary}`);
+  if (isJson) {
+    const content = skill.raw || `# ${skill.name}\n\n${formatSkill(skill)}\n`;
+    console.log(JSON.stringify({ name: skill.name, content }, null, 2));
+  } else {
+    console.log(formatSkill(skill));
   }
-  console.log("");
 }

package/src/commands/state.ts

@@ -0,0 +1,198 @@
+import * as path from "node:path";
+import {
+  readWorkflowState,
+  writeWorkflowState,
+  clearWorkflowState,
+  getLocalJeoDir,
+  type WorkflowState,
+} from "../agent/state";
+
+export interface ExtendedWorkflowState extends WorkflowState {
+  handoff_from?: string;
+}
+
+const allowedSkills = ["deep-interview", "ralplan", "team", "ultragoal"] as const;
+type Skill = typeof allowedSkills[number];
+
+function isSkill(val: string): val is Skill {
+  return allowedSkills.includes(val as Skill);
+}
+
+const allowedVerbs = ["read", "write", "clear", "handoff"] as const;
+type Verb = typeof allowedVerbs[number];
+
+function isVerb(val: string): val is Verb {
+  return allowedVerbs.includes(val as Verb);
+}
+
+function printUsage(): void {
+  console.log("Usage:");
+  console.log("  jeo state <skill> read [--json]");
+  console.log("  jeo state <skill> write --input '<json>' [--json]");
+  console.log("  jeo state <skill> clear");
+  console.log("  jeo state <skill> handoff --to <skill> [--json]");
+  console.log("");
+  console.log("Skills:");
+  console.log("  deep-interview, ralplan, team, ultragoal");
+  console.log("");
+  console.log("Verbs:");
+  console.log("  read, write, clear, handoff");
+}
+
+export async function runStateCommand(args: string[] = []): Promise<void> {
+  const cwd = process.cwd();
+
+  const isHelp = args.includes("--help") || args.includes("-h");
+  if (isHelp) {
+    printUsage();
+    process.exitCode = 0;
+    return;
+  }
+
+  if (args.length < 2) {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+
+  const skill = args[0];
+  const verb = args[1];
+
+  if (!isSkill(skill) || !isVerb(verb)) {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+
+  const isJson = args.includes("--json");
+
+  if (verb === "read") {
+    const state = await readWorkflowState(skill, cwd);
+    if (!state) {
+      console.log(`No state found for skill: ${skill}`);
+      return;
+    }
+    if (isJson) {
+      console.log(JSON.stringify(state, null, 2));
+    } else {
+      const statePath = path.join(getLocalJeoDir(cwd), "state", `${skill}-state.json`);
+      console.log(`Skill: ${state.skill}`);
+      console.log(`Current Phase: ${state.current_phase}`);
+      console.log(`File Path: ${statePath}`);
+      console.log("Details:");
+      for (const [key, val] of Object.entries(state)) {
+        if (key !== "skill" && key !== "current_phase") {
+          console.log(`  ${key}: ${typeof val === "object" ? JSON.stringify(val) : val}`);
+        }
+      }
+    }
+    return;
+  }
+
+  if (verb === "write") {
+    let inputJson: string | null = null;
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === "--input") {
+        inputJson = args[i + 1] || null;
+        i++;
+      } else if (args[i].startsWith("--input=")) {
+        inputJson = args[i].substring("--input=".length);
+      }
+    }
+
+    if (inputJson === null) {
+      console.log("[ERROR] --input option is required for write verb.");
+      process.exitCode = 1;
+      return;
+    }
+
+    let parsed: any;
+    try {
+      parsed = JSON.parse(inputJson);
+    } catch (err) {
+      console.log(`[ERROR] Malformed JSON input: ${(err as Error).message}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      console.log("[ERROR] Input must be a valid JSON object.");
+      process.exitCode = 1;
+      return;
+    }
+
+    const existing = await readWorkflowState(skill, cwd);
+    const merged: WorkflowState = {
+      active: false,
+      current_phase: "",
+      ...existing,
+      ...parsed,
+      skill,
+    };
+
+    const statePath = await writeWorkflowState(skill, merged, cwd);
+    if (isJson) {
+      console.log(`State path: ${statePath}`);
+      console.log(JSON.stringify(merged, null, 2));
+    } else {
+      console.log(`State path: ${statePath}`);
+    }
+    return;
+  }
+
+  if (verb === "clear") {
+    await clearWorkflowState(skill, cwd);
+    console.log(`Cleared state for skill: ${skill}`);
+    return;
+  }
+
+  if (verb === "handoff") {
+    let toSkill: string | null = null;
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === "--to") {
+        toSkill = args[i + 1] || null;
+        i++;
+      } else if (args[i].startsWith("--to=")) {
+        toSkill = args[i].substring("--to=".length);
+      }
+    }
+
+    if (!toSkill || !isSkill(toSkill)) {
+      console.log(`[ERROR] Target skill must be specified with --to <skill>. Allowed skills: ${allowedSkills.join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const sourceState = await readWorkflowState(skill, cwd) || {
+      active: false,
+      current_phase: "",
+      skill,
+    };
+    sourceState.current_phase = "handoff";
+    const sourcePath = await writeWorkflowState(skill, sourceState, cwd);
+
+    const targetState = await readWorkflowState(toSkill, cwd) || {
+      active: false,
+      current_phase: "",
+      skill: toSkill,
+    };
+    const updatedTarget: ExtendedWorkflowState = {
+      ...targetState,
+      active: true,
+      handoff_from: skill,
+    };
+    const targetPath = await writeWorkflowState(toSkill, updatedTarget, cwd);
+
+    if (isJson) {
+      console.log(JSON.stringify({
+        source: { path: sourcePath, state: sourceState },
+        target: { path: targetPath, state: updatedTarget }
+      }, null, 2));
+    } else {
+      console.log(`Handoff completed.`);
+      console.log(`Source (${skill}) state updated: ${sourcePath}`);
+      console.log(`Target (${toSkill}) state updated: ${targetPath}`);
+    }
+    return;
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,84 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import chalk from "chalk";
+
+export async function runStatusCommand(): Promise<void> {
+  const cwd = process.cwd();
+  const logPath = path.join(cwd, "logs", "evolution-log.json");
+  const perfPath = path.join(cwd, ".jeo", "state", "performance-metrics.json");
+  const planPath = path.join(cwd, ".specify", "plan.md");
+  
+  console.log(chalk.bold("\n=== jeo Core Engine Status ==="));
+  
+  try {
+    const planContent = await fs.readFile(planPath, "utf-8");
+    const tasks = planContent.match(/- \[[x ]\] .+/g) || [];
+    const completedTasks = tasks.filter(t => t.startsWith("- [x]")).length;
+    const totalTasks = tasks.length;
+    
+    if (totalTasks > 0) {
+      const percentage = (completedTasks / totalTasks) * 100;
+      const barWidth = 30;
+      const filledWidth = Math.round((completedTasks / totalTasks) * barWidth);
+      const bar = chalk.green("█").repeat(filledWidth) + chalk.gray("░").repeat(barWidth - filledWidth);
+      
+      console.log(chalk.bold("Overall Project Progress: [" + bar + "] " + percentage.toFixed(1) + "%"));
+      console.log(chalk.dim("(" + completedTasks + "/" + totalTasks + " tasks completed from plan.md)\n"));
+    }
+  } catch (e) {}
+
+  try {
+    const content = await fs.readFile(logPath, "utf-8");
+    const logs = JSON.parse(content);
+    
+    if (logs.length === 0) {
+      console.log("No evolution history found.");
+    } else {
+      const activeTask = logs.find((l: any) => l.status === "in_progress");
+      if (activeTask) {
+        console.log(chalk.yellow.bold("▶ ACTIVE EVOLUTION: ") + chalk.cyan(activeTask.target));
+        if (activeTask.stage) {
+          console.log(chalk.magenta("  Stage: ") + chalk.bold(activeTask.stage.toUpperCase()));
+        }
+        console.log(chalk.dim("  Started: " + activeTask.timestamp + "\n"));
+      }
+
+      console.log(chalk.bold("Recent Evolution Turns:"));
+      const recent = logs.slice(-5).reverse();
+      for (const entry of recent) {
+        const statusColor = entry.status === "success" ? chalk.green : (entry.status === "failed" ? chalk.red : chalk.yellow);
+        const stageLabel = entry.stage ? ` [${entry.stage.toUpperCase()}]` : "";
+        console.log("- " + chalk.dim("[" + new Date(entry.timestamp).toLocaleTimeString() + "]") + stageLabel.padEnd(16) + " " + statusColor(entry.status.toUpperCase().padEnd(11)) + " " + chalk.cyan(entry.target));
+      }
+      console.log("");
+    }
+  } catch (e) {
+    console.log("Status: Idle (No evolution logs)");
+  }
+
+  console.log(chalk.bold("=== Engine Performance Metrics ==="));
+  try {
+    const perfPathAlt = path.join(cwd, "logs", "performance-metrics.json");
+    let perfContent = "";
+    try {
+      perfContent = await fs.readFile(perfPath, "utf-8");
+    } catch {
+      perfContent = await fs.readFile(perfPathAlt, "utf-8");
+    }
+    const metrics = JSON.parse(perfContent);
+    if (metrics.length > 0) {
+      const recent = metrics.slice(-50);
+      const avgDuration = recent.reduce((sum: number, m: any) => sum + m.duration, 0) / recent.length;
+      const successRate = (recent.filter((m: any) => m.success).length / recent.length) * 100;
+      
+      console.log("Average Tool Time: " + chalk.magenta(avgDuration.toFixed(0) + "ms"));
+      const successColor = successRate > 90 ? chalk.green : chalk.yellow;
+      console.log("Tool Success Rate: " + successColor(successRate.toFixed(1) + "%"));
+    } else {
+      console.log("No performance metrics collected yet.");
+    }
+  } catch (e) {
+    console.log("Performance metrics unavailable.");
+  }
+  console.log("");
+}