@meshxdata/fops 0.0.1 → 0.0.4

package/README.md

@@ -1,4 +1,4 @@
-# Foundation CLI
+# Foundation Operator CLI (`fops`)
 
 Install and manage **Foundation** data mesh platforms from the terminal.
 
@@ -8,90 +8,112 @@ Install and manage **Foundation** data mesh platforms from the terminal.
 
 ```bash
 # Run without installing
-npx foundation doctor
+npx @meshxdata/fops doctor
 
 # Install globally
-npm install -g foundation
-# or
-pnpm add -g foundation
+npm install -g @meshxdata/fops
 ```
 
 **From repo (development)**
 
 ```bash
-cd foundation-compose/foundation-cli
+cd foundation-compose/operator-cli
 npm install
-npm link   # optional: use `foundation` from anywhere
+npm link   # optional: use `fops` from anywhere
 ```
 
 **Shell installer (optional)**
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/meshxdata/foundation-compose/main/foundation-cli/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/meshxdata/foundation-compose/main/operator-cli/install.sh | bash
 ```
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `foundation setup` | Full automated setup (`.env`, netrc reminder, submodules; use `--download` to pull images). Replaces `setup.sh`. |
-| `foundation init` | Initialize a Foundation project (submodules, `.env`); same as `setup` with default options |
-| `foundation up` | Start all services (`make start`) |
-| `foundation down` | Stop services; use `--clean` to remove volumes |
-| `foundation status` | Show service status |
-| `foundation logs [service]` | Stream logs (all or one service) |
-| `foundation doctor` | Check Docker, git, `.env`, project layout; use `--fix` to apply fixes |
-| `foundation config` | Launch interactive configuration |
-| `foundation bootstrap` | Create demo data mesh |
-| `foundation test` | Run health checks |
-| `foundation agent` | AI assistant for the stack. Interactive or single-turn with `-m "message"`. |
-| `foundation chat` | Same as `foundation agent` (interactive). |
+| `fops login` | Authenticate with Claude (default) or other services |
+| `fops login coda` | Authenticate with Coda (guided API token setup) |
+| `fops setup` | Full automated setup (`.env`, netrc reminder, submodules; use `--download` to pull images) |
+| `fops init` | Initialize a Foundation project. Interactive wizard when not in a project root. |
+| `fops up` | Start all services (`make start`); launches interactive AI assistant after startup |
+| `fops down` | Stop services; use `--clean` to remove volumes |
+| `fops status` | Show service status |
+| `fops logs [service]` | Stream logs (all or one service) |
+| `fops doctor` | Check Docker, git, `.env`, AWS/ECR, ports, services; use `--fix` to apply fixes |
+| `fops config` | Launch interactive configuration |
+| `fops bootstrap` | Create demo data mesh |
+| `fops test` | Run health checks |
+| `fops agent` | AI assistant for the stack. Interactive or single-turn with `-m "message"`. |
+| `fops chat` | Interactive AI assistant (same as `fops agent`) |
+| `fops skill list` | List available agent skills (built-in and plugin-provided) |
+| `fops plugin list` | List installed plugins |
+| `fops plugin install <source>` | Install a plugin from a local directory |
+| `fops plugin remove <id>` | Remove an installed plugin |
 
 ### AI Assistant (agent / chat)
 
-- **Interactive:** `foundation agent` or `foundation chat` — in-CLI chat (no Claude Code app). Uses Anthropic or OpenAI APIs with streaming.
-- **Single-turn:** `foundation agent -m "why are my containers failing?"` — one question, one reply; optional “run suggested command?” prompt.
+- **Interactive:** `fops agent` or `fops chat` — in-CLI chat with streaming responses and command execution.
+- **Single-turn:** `fops agent -m "why are my containers failing?"` — one question, one reply; optional "run suggested command?" prompt.
+- **Model override:** `fops agent --model claude-sonnet-4-20250514`
 
 **Auth** (checked in order):
 
-1. `ANTHROPIC_API_KEY` or `OPENAI_API_KEY` environment variable  
-2. `~/.claude/settings.json` → `apiKeyHelper` (script that prints the API key)  
-3. `~/.claude/.credentials.json` → `anthropic_api_key` or `apiKey`  
-4. `~/.claude.json` → `anthropic_api_key` or `apiKey`  
+1. Claude Code CLI OAuth (if `claude` is installed and authenticated)
+2. `ANTHROPIC_API_KEY` environment variable
+3. `~/.claude/settings.json` → `apiKeyHelper` (script that prints the API key)
+4. `~/.claude/.credentials.json` or `~/.claude.json` → `anthropic_api_key` / `apiKey`
+5. `OPENAI_API_KEY` environment variable (fallback; uses OpenAI-compatible models)
 
-On macOS, Claude Code stores keys in Keychain; use `apiKeyHelper` in `~/.claude/settings.json` pointing to a script that reads the key (e.g. from keychain) and prints it, or put a key in `~/.claude/.credentials.json`.  
+Run `fops login` to authenticate via OAuth browser flow, or `fops login --no-browser` to paste an API key directly.
 
-Install optional deps: `npm install @anthropic-ai/sdk openai`.
+**Coda** — Run `fops login coda` to set up your Coda API token. The wizard opens your browser to coda.io/account and guides you through generating and pasting the token. Token is validated via the Coda API and saved to `~/.fops.json`. You can also set `CODA_API_TOKEN` as an env var.
+
+### Doctor
+
+Checks prerequisites (Docker, Git, Node.js, AWS CLI), AWS/ECR access, project structure, Docker resources, port conflicts, running services, and image freshness. Plugins can register additional checks.
+
+On `--fix`, doctor can automatically:
+- Install Docker (macOS via Homebrew, Windows via winget, Linux via get.docker.com)
+- Start the Docker daemon
+- Fix AWS SSO sessions and ECR authentication
+- Create missing `.env` from `.env.example`
+- Run `fops init` for missing projects
+- Rebuild stale images
+
+### Plugins
+
+Plugins extend the CLI with custom commands, doctor checks, lifecycle hooks, and agent skills.
+
+- **Global plugins:** `~/.fops/plugins/<id>/` (each with `fops.plugin.json`)
+- **NPM plugins:** packages named `fops-plugin-*` or `@scope/fops-plugin-*`
 
 ## Usage
 
-Run from a **foundation-compose** clone (or any directory that contains `docker-compose.yaml` and `Makefile`). You can also set `FOUNDATION_ROOT` to point to your repo root.
+Run from a **foundation-compose** clone (or any directory containing `docker-compose.yaml` and `Makefile`). You can also set `FOUNDATION_ROOT` to point to your repo root.
 
 ```bash
 cd /path/to/foundation-compose
-foundation doctor
-foundation up
-foundation status
+fops doctor
+fops up
+fops status
 ```
 
 First-time setup:
 
 ```bash
-git clone https://github.com/meshxdata/foundation-compose
-cd foundation-compose
-npx foundation init
-npx foundation up
+fops init
+fops up
 ```
 
-## Project structure
-
-The CLI is split into modules under `src/` for long-term maintainability. See [STRUCTURE.md](STRUCTURE.md) for layout and how to add commands.
+The init wizard will prompt to clone the repository if no project is found.
 
 ## Requirements
 
 - Node.js >= 18
 - Docker (Docker Compose)
-- Git (for `foundation init` submodules)
+- Git (for submodules)
+- Claude CLI (bundled — installed automatically via `npm install`)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshxdata/fops",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "CLI to install and manage Foundation data mesh platforms",
   "keywords": [
     "foundation",
@@ -16,8 +16,8 @@
   "files": [
     "foundation.mjs",
     "src/",
-    "README.md",
-    "STRUCTURE.md"
+    "!src/**/*.test.js",
+    "README.md"
   ],
   "scripts": {
     "start": "node foundation.mjs",
@@ -25,6 +25,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@anthropic-ai/claude-code": "^1.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",

package/src/agent/agent.js

@@ -1,9 +1,10 @@
 import chalk from "chalk";
 import { execa } from "execa";
 import { resolveAnthropicApiKey, resolveOpenAiApiKey, authHelp, offerClaudeLogin } from "../auth/index.js";
-import { renderSpinner, renderBanner, promptInput, selectOption } from "../ui/index.js";
-import { FOUNDATION_SYSTEM_PROMPT, gatherStackContext } from "./context.js";
-import { hasClaudeCode, hasClaudeCodeAuth, runViaClaudeCode, streamAssistantReply } from "./llm.js";
+import { PKG } from "../config.js";
+import { renderBanner, promptInput, selectOption } from "../ui/index.js";
+import { FOUNDATION_SYSTEM_PROMPT, gatherStackContext, getFoundationContextBlock } from "./context.js";
+import { hasClaudeCode, hasClaudeCodeAuth, streamAssistantReply } from "./llm.js";
 
 /**
  * Render inline markdown: **bold**, *italic*, `code`
@@ -39,13 +40,13 @@ export function formatResponse(text) {
         const isShell = /^(bash|sh|shell|zsh)?$/.test(codeLang);
         const maxLen = Math.max(...codeBlock.map((l) => l.length), 0);
         const width = Math.max(maxLen + 4, 20);
-        const top = chalk.gray("  ┌" + "─".repeat(width) + "┐");
-        const bot = chalk.gray("  └" + "─".repeat(width) + "┘");
+        const top = chalk.dim("  ┌" + "─".repeat(width) + "┐");
+        const bot = chalk.dim("  └" + "─".repeat(width) + "┘");
         out.push(top);
         for (const cl of codeBlock) {
           const prefix = isShell ? chalk.green("$ ") : "  ";
           const pad = " ".repeat(Math.max(0, width - cl.length - (isShell ? 4 : 2)));
-          out.push(chalk.gray("  │ ") + prefix + chalk.white(cl) + chalk.gray(pad + " │"));
+          out.push(chalk.dim("  │ ") + prefix + chalk.white(cl) + chalk.dim(pad + " │"));
         }
         out.push(bot);
         inCode = false;
@@ -71,7 +72,7 @@ export function formatResponse(text) {
     // Blockquote
     if (/^>\s?/.test(line)) {
       const content = line.replace(/^>\s?/, "");
-      out.push(chalk.gray.italic("  " + renderInline(content)));
+      out.push(chalk.dim.italic("  " + renderInline(content)));
       continue;
     }
 
@@ -123,9 +124,9 @@ async function runShellCommand(root, command, { isLast = true } = {}) {
   const trimmed = command.replace(/\s+/g, " ").trim();
   const branch = isLast ? "└─" : "├─";
   const cont = isLast ? "   " : "│  ";
-  const prefix = `   ${chalk.gray(cont)}`;
+  const prefix = `   ${chalk.dim(cont)}`;
 
-  console.log(`\n   ${chalk.gray(branch)} ${chalk.white(trimmed)} ${chalk.gray("· running")}`);
+  console.log(`\n   ${chalk.dim(branch)} ${chalk.white(trimmed)} ${chalk.dim("· running")}`);
 
   try {
     // Pipe stdout/stderr so docker/compose use clean non-TTY output
@@ -149,7 +150,7 @@ async function runShellCommand(root, command, { isLast = true } = {}) {
         const line = raw.includes("\r") ? raw.split("\r").filter(Boolean).pop() : raw;
         if (!line?.trim()) continue;
         if (lastWasCR) process.stdout.write("\n");
-        process.stdout.write(`${prefix}${chalk.gray(line)}`);
+        process.stdout.write(`${prefix}${chalk.dim(line)}`);
         lastWasCR = raw.includes("\r") && !raw.endsWith("\n");
         if (!lastWasCR) process.stdout.write("\n");
       }
@@ -174,34 +175,59 @@ async function runShellCommand(root, command, { isLast = true } = {}) {
   }
 }
 
+/**
+ * Check if a command matches any plugin-registered auto-run pattern.
+ */
+function isAutoRun(command, registry) {
+  if (!registry?.autoRunPatterns?.length) return false;
+  return registry.autoRunPatterns.some(({ pattern }) => command.trimStart().startsWith(pattern));
+}
+
 /**
  * Present suggested commands in a single picker.
- * Shows each command as a selectable option plus "Run all" / "Skip".
+ * Commands matching plugin autoRunPatterns execute immediately.
+ * Others show as selectable options plus "Run all" / "Skip".
  * Returns array of { command, ok, output } for commands that were run.
  */
-export async function askToRunCommand(root, replyText) {
+export async function askToRunCommand(root, replyText, registry) {
   const suggested = extractSuggestedCommands(replyText);
   if (suggested.length === 0) return [];
 
-  console.log(chalk.cyan("⏺") + chalk.white(" Suggested commands:"));
+  // Split into auto-run and interactive commands
+  const autoRun = suggested.filter((cmd) => isAutoRun(cmd, registry));
+  const interactive = suggested.filter((cmd) => !isAutoRun(cmd, registry));
+
+  const results = [];
 
-  const options = suggested.map((cmd) => ({ label: cmd, value: cmd }));
-  if (suggested.length > 1) {
-    options.push({ label: "Run all", value: "__run_all__" });
+  // Execute auto-run commands immediately
+  if (autoRun.length > 0) {
+    for (let i = 0; i < autoRun.length; i++) {
+      const isLast = i === autoRun.length - 1 && interactive.length === 0;
+      const result = await runShellCommand(root, autoRun[i], { isLast });
+      results.push({ command: autoRun[i], ...result });
+    }
   }
-  options.push({ label: "Skip", value: "__skip__" });
 
-  const choice = await selectOption("Run command?", options);
+  // Prompt for remaining interactive commands
+  if (interactive.length > 0) {
+    console.log(chalk.cyan("⏺") + chalk.white(" Suggested commands:"));
 
-  if (choice === null || choice === "__skip__") return [];
+    const options = interactive.map((cmd) => ({ label: cmd, value: cmd }));
+    if (interactive.length > 1) {
+      options.push({ label: "Run all", value: "__run_all__" });
+    }
+    options.push({ label: "Skip", value: "__skip__" });
 
-  const toRun = choice === "__run_all__" ? suggested : [choice];
-  const results = [];
+    const choice = await selectOption("Run command?", options);
 
-  for (let i = 0; i < toRun.length; i++) {
-    const isLast = i === toRun.length - 1;
-    const result = await runShellCommand(root, toRun[i], { isLast });
-    results.push({ command: toRun[i], ...result });
+    if (choice !== null && choice !== "__skip__") {
+      const toRun = choice === "__run_all__" ? interactive : [choice];
+      for (let i = 0; i < toRun.length; i++) {
+        const isLast = i === toRun.length - 1;
+        const result = await runShellCommand(root, toRun[i], { isLast });
+        results.push({ command: toRun[i], ...result });
+      }
+    }
   }
 
   return results;
@@ -209,6 +235,7 @@ export async function askToRunCommand(root, replyText) {
 
 export async function runAgentSingleTurn(root, message, opts = {}) {
   const runSuggestions = opts.runSuggestions !== false;
+  const registry = opts.registry;
   const useClaudeCode = hasClaudeCode() && hasClaudeCodeAuth();
   const anthropicKey = resolveAnthropicApiKey();
   const openaiKey = resolveOpenAiApiKey();
@@ -218,36 +245,18 @@ export async function runAgentSingleTurn(root, message, opts = {}) {
     process.exit(1);
   }
 
-  const context = await gatherStackContext(root);
+  const context = await gatherStackContext(root, { registry, message });
   const systemContent = FOUNDATION_SYSTEM_PROMPT + "\n\n" + context;
-  let replyText = "";
-
-  const spinner = renderSpinner();
 
+  let replyText = "";
   try {
-    if (useClaudeCode) {
-      // Use Claude Code CLI with OAuth auth
-      replyText = await runViaClaudeCode(message, systemContent);
-    } else if (anthropicKey) {
-      const { default: Anthropic } = await import("@anthropic-ai/sdk");
-      const client = new Anthropic({ apiKey: anthropicKey });
-      const response = await client.messages.create({
-        model: opts.model || "claude-sonnet-4-20250514",
-        max_tokens: 2048, system: systemContent,
-        messages: [{ role: "user", content: message }],
-      });
-      replyText = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-    } else if (openaiKey) {
-      const OpenAI = (await import("openai")).default;
-      const client = new OpenAI({ apiKey: openaiKey });
-      const response = await client.chat.completions.create({
-        model: opts.model || "gpt-4o-mini", max_tokens: 2048,
-        messages: [{ role: "system", content: systemContent }, { role: "user", content: message }],
-      });
-      replyText = response.choices?.[0]?.message?.content ?? "";
-    }
+    replyText = await streamAssistantReply(
+      root,
+      [{ role: "user", content: message }],
+      systemContent,
+      opts,
+    );
   } catch (err) {
-    spinner.stop();
     if (err.code === "MODULE_NOT_FOUND" || err.message?.includes("Cannot find module")) {
       console.log(chalk.yellow("Install optional deps for agent: npm install @anthropic-ai/sdk openai"));
       process.exit(1);
@@ -260,33 +269,33 @@ export async function runAgentSingleTurn(root, message, opts = {}) {
         console.log(chalk.green("Login complete. Run your command again.\n"));
         process.exit(0);
       }
-      console.log(chalk.gray("Get a valid key from console.anthropic.com (we can open the page in your browser on next run).\n"));
+      console.log(chalk.dim("Get a valid key from console.anthropic.com (we can open the page in your browser on next run).\n"));
       process.exit(1);
     }
     throw err;
   }
 
-  spinner.stop();
   console.log("");
   console.log(formatResponse(replyText));
   console.log("");
 
   if (runSuggestions) {
-    const cmdResults = await askToRunCommand(root, replyText);
+    const cmdResults = await askToRunCommand(root, replyText, registry);
     if (cmdResults.some((r) => !r.ok)) {
       console.log(chalk.yellow("\n  Some commands failed. Run fops chat for interactive help.\n"));
     }
   }
 }
 
-export async function runAgentInteractive(root) {
+export async function runAgentInteractive(root, opts = {}) {
+  const registry = opts.registry;
   const useClaudeCode = hasClaudeCode() && hasClaudeCodeAuth();
   const anthropicKey = resolveAnthropicApiKey();
   const openaiKey = resolveOpenAiApiKey();
 
   if (!useClaudeCode && !anthropicKey && !openaiKey) {
     authHelp();
-    console.log(chalk.gray("  npm install @anthropic-ai/sdk openai   # optional deps\n"));
+    console.log(chalk.dim("  npm install @anthropic-ai/sdk openai   # optional deps\n"));
     process.exit(1);
   }
 
@@ -301,38 +310,123 @@ export async function runAgentInteractive(root) {
     }
   }
 
-  const context = await gatherStackContext(root);
-  const systemContent = FOUNDATION_SYSTEM_PROMPT + "\n\n" + context;
+  // Gather base context (without message-specific RAG — that happens per-turn)
+  const baseContext = await gatherStackContext(root, { registry });
   const messages = [];
+  let activeAgent = null;
+
+  // Auto-activate agent if requested (e.g. debug agent on startup failure)
+  if (opts.initialAgent) {
+    const agents = registry?.agents || [];
+    const found = agents.find((a) => a.name === opts.initialAgent);
+    if (found) {
+      activeAgent = found;
+    }
+  }
 
   // Show banner
   renderBanner();
 
-  // Show quick hints
-  console.log(chalk.gray("  Try: \"help me set up\" • \"what's running?\" • \"show logs\" • \"run diagnostics\"\n"));
+  if (activeAgent) {
+    console.log(chalk.cyan(`  Agent: ${chalk.bold(activeAgent.name)} — ${activeAgent.description}`));
+    console.log(chalk.dim("  /exit-agent to return to general mode • /agents to list specialists\n"));
+  } else {
+    // Show quick hints
+    console.log(chalk.dim("  Try: \"help me set up\" • \"what's running?\" • \"/agents\" to list specialists\n"));
+  }
 
   // Main chat loop
   while (true) {
-    const input = await promptInput();
+    const statusLabel = activeAgent
+      ? `fops v${PKG.version} \u00b7 agent:${activeAgent.name} \u00b7 /exit-agent \u00b7 /exit to quit`
+      : `fops v${PKG.version} \u00b7 /agents \u00b7 /exit to quit \u00b7 \u2191\u2193 history`;
+    const input = await promptInput(statusLabel);
 
     // Exit on null (esc/ctrl+c) or exit command
     if (input === null || /^\/(exit|quit|q)$/i.test(input)) {
-      console.log(chalk.gray("\nGoodbye!\n"));
+      console.log(chalk.dim("\nGoodbye!\n"));
       break;
     }
 
-    if (!input.trim()) continue;
+    // /agents — list available agents
+    if (/^\/agents$/i.test(input.trim())) {
+      const agents = registry?.agents || [];
+      if (agents.length === 0) {
+        console.log(chalk.yellow("\n  No agents available.\n"));
+      } else {
+        console.log(chalk.cyan("\n  Available agents:\n"));
+        for (const a of agents) {
+          const active = activeAgent?.name === a.name ? chalk.green(" (active)") : "";
+          console.log(`  ${chalk.bold(a.name)}${active} — ${chalk.dim(a.description)}`);
+        }
+        console.log(chalk.dim(`\n  Usage: /agent <name> [task]\n`));
+      }
+      continue;
+    }
+
+    // /agent <name> [task] — activate an agent
+    const agentMatch = input.trim().match(/^\/agent\s+(\S+)(?:\s+(.+))?$/i);
+    if (agentMatch) {
+      const agentName = agentMatch[1];
+      const inlineTask = agentMatch[2] || null;
+      const agents = registry?.agents || [];
+      const found = agents.find((a) => a.name === agentName);
+      if (!found) {
+        console.log(chalk.yellow(`\n  Unknown agent "${agentName}". Use /agents to see available agents.\n`));
+        continue;
+      }
+      activeAgent = found;
+      console.log(chalk.cyan(`\n  Activated agent: ${chalk.bold(found.name)} — ${found.description}\n`));
+      if (!inlineTask) continue;
+      // Fall through with the inline task as user input
+      messages.push({ role: "user", content: inlineTask });
+    } else {
+      // /exit-agent — deactivate agent
+      if (/^\/exit-agent$/i.test(input.trim())) {
+        if (!activeAgent) {
+          console.log(chalk.dim("\n  No agent active.\n"));
+        } else {
+          console.log(chalk.dim(`\n  Deactivated agent: ${activeAgent.name}\n`));
+          activeAgent = null;
+        }
+        continue;
+      }
+
+      if (!input.trim()) continue;
 
-    messages.push({ role: "user", content: input });
+      messages.push({ role: "user", content: input });
+    }
 
     try {
-      const replyText = await streamAssistantReply(root, messages, systemContent, {});
+      // Re-gather knowledge per turn so RAG is query-specific
+      let ragBlock = null;
+      if (registry) {
+        const { searchKnowledge } = await import("../plugins/knowledge.js");
+        ragBlock = await searchKnowledge(registry, messages[messages.length - 1].content);
+      }
+
+      // Build system prompt — use agent's prompt when active
+      let systemContent;
+      if (activeAgent) {
+        const contextBlock = activeAgent.contextMode === "minimal"
+          ? getFoundationContextBlock(root)
+          : baseContext;
+        systemContent = activeAgent.systemPrompt + "\n\n" + contextBlock
+          + (ragBlock ? "\n\n" + ragBlock : "");
+      } else {
+        systemContent = FOUNDATION_SYSTEM_PROMPT + "\n\n" + baseContext
+          + (ragBlock ? "\n\n" + ragBlock : "");
+      }
+
+      const replyText = await streamAssistantReply(root, messages, systemContent, {
+        replaceSystemPrompt: !!activeAgent,
+      });
       console.log("");
       console.log(formatResponse(replyText));
       console.log("");
       messages.push({ role: "assistant", content: replyText });
 
-      const cmdResults = await askToRunCommand(root, replyText);
+      const cmdResults = await askToRunCommand(root, replyText, registry);
       // Feed command outputs back into context so the AI knows what happened
       if (cmdResults.length > 0) {
         const summary = cmdResults.map((r) =>
@@ -342,7 +436,6 @@ export async function runAgentInteractive(root) {
 
         // Auto-follow-up if any command failed
         if (cmdResults.some((r) => !r.ok)) {
-          console.log("");
           const followUp = await streamAssistantReply(root, messages, systemContent, {});
           console.log("");
           console.log(formatResponse(followUp));
@@ -358,7 +451,7 @@ export async function runAgentInteractive(root) {
         console.log(chalk.red("\nAuthentication failed: invalid or expired API key."));
         const didLogin = await offerClaudeLogin();
         if (didLogin) console.log(chalk.green("\nLogin complete. Try your message again.\n"));
-        else console.log(chalk.gray("Get a valid key from console.anthropic.com\n"));
+        else console.log(chalk.dim("Get a valid key from console.anthropic.com\n"));
       } else {
         console.log(chalk.red("\nError:"), err.message);
       }