@meshxdata/fops 0.0.1 → 0.0.4

package/src/agent/llm.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { execa, execaSync } from "execa";
 import { resolveAnthropicApiKey, resolveOpenAiApiKey, readClaudeCodeKeychain } from "../auth/index.js";
-import { renderSpinner } from "../ui/index.js";
+import { renderThinking } from "../ui/index.js";
 
 // Check if Claude Code CLI is available
 export function hasClaudeCode() {
@@ -37,10 +37,10 @@ function buildConversationPrompt(messages) {
 /**
  * Run a prompt through Claude Code CLI (uses OAuth auth)
  */
-export async function runViaClaudeCode(prompt, systemPrompt) {
+export async function runViaClaudeCode(prompt, systemPrompt, { replaceSystemPrompt = false } = {}) {
   const args = ["-p", "--no-session-persistence"];
   if (systemPrompt) {
-    args.push("--append-system-prompt", systemPrompt);
+    args.push(replaceSystemPrompt ? "--system-prompt" : "--append-system-prompt", systemPrompt);
   }
 
   const { stdout } = await execa("claude", args, {
@@ -53,12 +53,20 @@ export async function runViaClaudeCode(prompt, systemPrompt) {
 }
 
 /**
- * Stream response via Claude Code CLI with thinking display
+ * Stream response via Claude Code CLI with thinking display.
+ * Uses --output-format stream-json --include-partial-messages to get
+ * token-level streaming events (content_block_delta for text and thinking).
  */
-export async function streamViaClaudeCode(prompt, systemPrompt, onChunk, onThinking) {
-  const args = ["-p", "--no-session-persistence"];
+export async function streamViaClaudeCode(prompt, systemPrompt, onChunk, onThinking, onBlockStart, { replaceSystemPrompt = false } = {}) {
+  const args = [
+    "-p",
+    "--output-format", "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--no-session-persistence",
+  ];
   if (systemPrompt) {
-    args.push("--append-system-prompt", systemPrompt);
+    args.push(replaceSystemPrompt ? "--system-prompt" : "--append-system-prompt", systemPrompt);
   }
 
   const proc = execa("claude", args, {
@@ -68,14 +76,62 @@ export async function streamViaClaudeCode(prompt, systemPrompt, onChunk, onThink
   });
 
   let fullText = "";
+  let lineBuf = "";
 
   proc.stdout.on("data", (chunk) => {
-    const text = chunk.toString();
-    fullText += text;
-    if (onChunk) onChunk(text);
+    lineBuf += chunk.toString();
+    const lines = lineBuf.split("\n");
+    lineBuf = lines.pop(); // keep incomplete line
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let evt;
+      try { evt = JSON.parse(line); } catch { continue; }
+
+      if (evt.type === "stream_event") {
+        const inner = evt.event;
+        if (inner?.type === "content_block_start") {
+          const blockType = inner.content_block?.type;
+          if (onBlockStart) onBlockStart(blockType);
+        } else if (inner?.type === "content_block_delta") {
+          if (inner.delta?.type === "thinking_delta" && inner.delta.thinking) {
+            if (onThinking) onThinking(inner.delta.thinking);
+          }
+          if (inner.delta?.type === "text_delta" && inner.delta.text) {
+            fullText += inner.delta.text;
+            if (onChunk) onChunk(inner.delta.text);
+          }
+        }
+      } else if (evt.type === "assistant") {
+        // Final assistant message — extract any remaining text
+        const content = evt.message?.content || [];
+        const textParts = content.filter(b => b.type === "text").map(b => b.text).join("");
+        // Only use this if streaming didn't capture everything
+        if (textParts && !fullText) {
+          fullText = textParts;
+          if (onChunk) onChunk(textParts);
+        }
+      }
+    }
   });
 
   await proc;
+
+  // Process any remaining buffer
+  if (lineBuf.trim()) {
+    try {
+      const evt = JSON.parse(lineBuf);
+      if (evt.type === "assistant") {
+        const content = evt.message?.content || [];
+        const textParts = content.filter(b => b.type === "text").map(b => b.text).join("");
+        if (textParts && !fullText) {
+          fullText = textParts;
+          if (onChunk) onChunk(textParts);
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
   return fullText;
 }
 
@@ -86,22 +142,76 @@ export async function streamAssistantReply(root, messages, systemContent, opts)
   const model = opts.model || (anthropicKey ? "claude-sonnet-4-20250514" : "gpt-4o-mini");
 
   let fullText = "";
-  const spinner = renderSpinner();
+  const display = renderThinking();
 
   try {
     if (useClaudeCode) {
-      // Build full conversation prompt so context is preserved between turns
       const prompt = buildConversationPrompt(messages);
-      fullText = await streamViaClaudeCode(prompt, systemContent);
+      fullText = await streamViaClaudeCode(
+        prompt,
+        systemContent,
+        (chunk) => {
+          display.appendContent(chunk);
+        },
+        (thinking) => {
+          display.appendThinking(thinking);
+        },
+        (blockType) => {
+          if (blockType === "thinking") {
+            display.setStatus("Reasoning");
+          } else if (blockType === "text") {
+            display.setThinking(""); // clear thinking preview
+            display.setStatus("Responding");
+          }
+        },
+        { replaceSystemPrompt: !!opts.replaceSystemPrompt },
+      );
     } else if (anthropicKey) {
       const { default: Anthropic } = await import("@anthropic-ai/sdk");
       const client = new Anthropic({ apiKey: anthropicKey });
-      const stream = await client.messages.create({
-        model, max_tokens: 2048, system: systemContent, messages, stream: true,
-      });
+      const isClaudeModel = model.includes("claude");
+
+      const createParams = {
+        model, max_tokens: isClaudeModel ? 16000 : 2048,
+        system: systemContent, messages, stream: true,
+      };
+
+      // Enable extended thinking for Claude models
+      if (isClaudeModel) {
+        createParams.thinking = { type: "enabled", budget_tokens: 10000 };
+      }
+
+      let stream;
+      try {
+        stream = await client.messages.create(createParams);
+      } catch (err) {
+        // Fall back to regular streaming if extended thinking is unsupported
+        if (isClaudeModel && (err?.status === 400 || err?.status === 422)) {
+          delete createParams.thinking;
+          createParams.max_tokens = 2048;
+          stream = await client.messages.create(createParams);
+        } else {
+          throw err;
+        }
+      }
+
       for await (const event of stream) {
-        if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
-          fullText += event.delta.text;
+        if (event.type === "content_block_start") {
+          if (event.content_block?.type === "thinking") {
+            display.setStatus("Reasoning");
+          } else if (event.content_block?.type === "text") {
+            display.setThinking(""); // clear thinking preview
+            display.setStatus("Responding");
+          }
+        }
+        if (event.type === "content_block_delta") {
+          if (event.delta?.type === "thinking_delta" && event.delta.thinking) {
+            display.appendThinking(event.delta.thinking);
+          }
+          if (event.delta?.type === "text_delta" && event.delta.text) {
+            fullText += event.delta.text;
+            display.setContent(fullText);
+          }
         }
       }
     } else if (openaiKey) {
@@ -114,13 +224,17 @@ export async function streamAssistantReply(root, messages, systemContent, opts)
       });
       for await (const chunk of stream) {
         const delta = chunk.choices?.[0]?.delta?.content;
-        if (delta) fullText += delta;
+        if (delta) {
+          fullText += delta;
+          display.setStatus("Responding");
+          display.setContent(fullText);
+        }
       }
     } else {
       throw new Error("No API key (use ANTHROPIC_API_KEY, OPENAI_API_KEY, or ~/.claude auth)");
     }
   } finally {
-    spinner.stop();
+    display.stop();
   }
 
   return fullText;

package/src/auth/coda.js

@@ -0,0 +1,128 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { openBrowser } from "./login.js";
+
+const CODA_ACCOUNT_URL = "https://coda.io/account";
+const FOPS_CONFIG_PATH = path.join(os.homedir(), ".fops.json");
+
+function readFopsConfig() {
+  try {
+    if (fs.existsSync(FOPS_CONFIG_PATH)) {
+      return JSON.parse(fs.readFileSync(FOPS_CONFIG_PATH, "utf8"));
+    }
+  } catch {}
+  return {};
+}
+
+function saveFopsConfig(config) {
+  fs.writeFileSync(FOPS_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+}
+
+export function resolveCodaApiToken() {
+  const envToken = process.env.CODA_API_TOKEN?.trim();
+  if (envToken) return envToken;
+  try {
+    const config = readFopsConfig();
+    const token = config.coda?.apiToken?.trim();
+    if (token) return token;
+  } catch {}
+  return null;
+}
+
+function saveCodaToken(token) {
+  const config = readFopsConfig();
+  config.coda = { ...config.coda, apiToken: token.trim() };
+  saveFopsConfig(config);
+}
+
+async function validateCodaToken(token) {
+  try {
+    const res = await fetch("https://coda.io/apis/v1/whoami", {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return { valid: true, name: data.name, loginId: data.loginId };
+    }
+    if (res.status === 401 || res.status === 403) {
+      return { valid: false, error: "Invalid or expired API token." };
+    }
+    return { valid: false, error: `Coda API returned ${res.status}.` };
+  } catch (err) {
+    return { valid: false, error: `Could not reach Coda API: ${err.message}` };
+  }
+}
+
+export async function runCodaLogin() {
+  const existing = resolveCodaApiToken();
+  if (existing) {
+    const masked = existing.slice(0, 8) + "..." + existing.slice(-4);
+    const { overwrite } = await inquirer.prompt([{
+      type: "confirm",
+      name: "overwrite",
+      message: `Already have a Coda API token (${masked}). Replace it?`,
+      default: false,
+    }]);
+    if (!overwrite) {
+      console.log(chalk.dim("Keeping existing Coda token."));
+      return true;
+    }
+  }
+
+  console.log("");
+  console.log(chalk.bold.cyan("  Coda API Token Setup"));
+  console.log("");
+  console.log(chalk.white("  To connect Foundation to Coda, you need an API token."));
+  console.log(chalk.white("  Here's how to get one:\n"));
+  console.log(chalk.dim("  1. Go to ") + chalk.cyan(CODA_ACCOUNT_URL));
+  console.log(chalk.dim("  2. Scroll to ") + chalk.white("\"API Settings\""));
+  console.log(chalk.dim("  3. Click ") + chalk.white("\"Generate API token\""));
+  console.log(chalk.dim("  4. Give it a name (e.g. \"Foundation CLI\")"));
+  console.log(chalk.dim("  5. Copy the token and paste it below"));
+  console.log("");
+
+  const { openIt } = await inquirer.prompt([{
+    type: "confirm",
+    name: "openIt",
+    message: "Open Coda account page in your browser?",
+    default: true,
+  }]);
+
+  if (openIt) {
+    const opened = openBrowser(CODA_ACCOUNT_URL);
+    if (!opened) {
+      console.log(chalk.yellow("\n  Could not open browser. Visit: " + CODA_ACCOUNT_URL + "\n"));
+    } else {
+      console.log("");
+    }
+  }
+
+  const { token } = await inquirer.prompt([{
+    type: "password",
+    name: "token",
+    message: "Paste your Coda API token:",
+    mask: "*",
+    validate: (v) => {
+      if (!v?.trim()) return "API token is required.";
+      return true;
+    },
+  }]);
+
+  console.log(chalk.dim("\n  Validating token..."));
+  const result = await validateCodaToken(token.trim());
+
+  if (!result.valid) {
+    console.log(chalk.red(`\n  ${result.error}`));
+    console.log(chalk.dim("  Check the token and try again with: fops login coda\n"));
+    return false;
+  }
+
+  saveCodaToken(token);
+  console.log(chalk.green(`\n  Coda login successful!`));
+  console.log(chalk.dim(`  Logged in as: ${result.name || result.loginId}`));
+  console.log(chalk.dim("  Token saved to ~/.fops.json\n"));
+  return true;
+}

package/src/auth/index.js

@@ -2,3 +2,4 @@ export { resolveAnthropicApiKey, resolveOpenAiApiKey, readJsonKey } from "./reso
 export { readClaudeCodeKeychain } from "./keychain.js";
 export { authHelp, offerClaudeLogin, runLogin } from "./login.js";
 export { runOAuthLogin } from "./oauth.js";
+export { runCodaLogin, resolveCodaApiToken } from "./coda.js";

package/src/auth/login.js

@@ -9,10 +9,10 @@ const ANTHROPIC_KEYS_URL = "https://console.anthropic.com/settings/keys";
 
 export function authHelp() {
   console.log(chalk.yellow("No API key found. Try one of:"));
-  console.log(chalk.gray("  • Open " + chalk.cyan(ANTHROPIC_KEYS_URL) + " in your browser to sign in and create a key"));
-  console.log(chalk.gray("  • ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
-  console.log(chalk.gray("  • ~/.claude/.credentials.json with anthropic_api_key or apiKey"));
-  console.log(chalk.gray("  • ~/.claude/settings.json with apiKeyHelper (script that prints the key)\n"));
+  console.log(chalk.dim("  • Open " + chalk.cyan(ANTHROPIC_KEYS_URL) + " in your browser to sign in and create a key"));
+  console.log(chalk.dim("  • ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+  console.log(chalk.dim("  • ~/.claude/.credentials.json with anthropic_api_key or apiKey"));
+  console.log(chalk.dim("  • ~/.claude/settings.json with apiKeyHelper (script that prints the key)\n"));
 }
 
 export function openBrowser(url) {
@@ -46,7 +46,7 @@ export function saveApiKey(apiKey) {
   fs.writeFileSync(CLAUDE_CREDENTIALS, JSON.stringify(creds, null, 2) + "\n", { mode: 0o600 });
 
   console.log(chalk.green("\nLogin successful"));
-  console.log(chalk.gray("Key saved to ~/.claude/.credentials.json\n"));
+  console.log(chalk.dim("Key saved to ~/.claude/.credentials.json\n"));
   return true;
 }
 
@@ -65,11 +65,11 @@ export async function offerClaudeLogin() {
   if (!opened) {
     console.log(chalk.yellow("  Could not open browser. Visit: " + ANTHROPIC_KEYS_URL + "\n"));
   }
-  console.log(chalk.gray("  1. Sign in and create an API key"));
-  console.log(chalk.gray("  2. Add it to ~/.claude/.credentials.json:"));
-  console.log(chalk.gray('     { "anthropic_api_key": "sk-ant-..." }'));
-  console.log(chalk.gray("  3. Or run: export ANTHROPIC_API_KEY=\"sk-ant-...\""));
-  console.log(chalk.gray("  4. Then run foundation chat again.\n"));
+  console.log(chalk.dim("  1. Sign in and create an API key"));
+  console.log(chalk.dim("  2. Add it to ~/.claude/.credentials.json:"));
+  console.log(chalk.dim('     { "anthropic_api_key": "sk-ant-..." }'));
+  console.log(chalk.dim("  3. Or run: export ANTHROPIC_API_KEY=\"sk-ant-...\""));
+  console.log(chalk.dim("  4. Then run foundation chat again.\n"));
   return true;
 }
 
@@ -310,7 +310,7 @@ export async function runLogin(options = {}) {
       },
     ]);
     if (!overwrite) {
-      console.log(chalk.gray("Keeping existing credentials."));
+      console.log(chalk.dim("Keeping existing credentials."));
       return true;
     }
   }
@@ -405,8 +405,8 @@ async function runDeviceLogin() {
       const url = `http://127.0.0.1:${port}`;
 
       console.log(chalk.blue("\nOpening browser for authentication...\n"));
-      console.log(chalk.gray(`  If browser doesn't open, visit: ${chalk.cyan(url)}\n`));
-      console.log(chalk.gray("  Waiting for authentication..."));
+      console.log(chalk.dim(`  If browser doesn't open, visit: ${chalk.cyan(url)}\n`));
+      console.log(chalk.dim("  Waiting for authentication..."));
 
       openBrowser(url);
     });

package/src/auth/oauth.js

@@ -153,9 +153,9 @@ export async function runOAuthLogin() {
 
           console.log(chalk.green("\nLogin successful"));
           if (process.platform === "darwin") {
-            console.log(chalk.gray("Token saved to macOS Keychain\n"));
+            console.log(chalk.dim("Token saved to macOS Keychain\n"));
           } else {
-            console.log(chalk.gray("Token saved to ~/.claude/.credentials.json\n"));
+            console.log(chalk.dim("Token saved to ~/.claude/.credentials.json\n"));
           }
 
           server.close();
@@ -187,8 +187,8 @@ export async function runOAuthLogin() {
       authUrl.searchParams.set("code_challenge_method", "S256");
 
       console.log(chalk.blue("\nOpening browser for Claude login...\n"));
-      console.log(chalk.gray(`  If browser doesn't open, visit:\n  ${chalk.cyan(authUrl.toString())}\n`));
-      console.log(chalk.gray("  Waiting for authentication..."));
+      console.log(chalk.dim(`  If browser doesn't open, visit:\n  ${chalk.cyan(authUrl.toString())}\n`));
+      console.log(chalk.dim("  Waiting for authentication..."));
 
       openBrowser(authUrl.toString());
     });

package/src/commands/index.js

@@ -4,13 +4,15 @@ import path from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { PKG } from "../config.js";
-import { rootDir, requireRoot, hasComposeInDir, isFoundationRoot, findComposeRootUp } from "../project.js";
-import { make } from "../shell.js";
+import { rootDir, requireRoot, hasComposeInDir, isFoundationRoot, findComposeRootUp, checkInitState } from "../project.js";
+import { execa } from "execa";
+import { make, dockerCompose } from "../shell.js";
 import { runSetup, runInitWizard } from "../setup/index.js";
 import { ensureEcrAuth } from "../setup/aws.js";
 import { runAgentSingleTurn, runAgentInteractive } from "../agent/index.js";
 import { runDoctor } from "../doctor.js";
-import { runLogin } from "../auth/index.js";
+import { runFeatureFlags } from "../feature-flags.js";
+import { runLogin, runCodaLogin } from "../auth/index.js";
 import { runHook, loadSkills } from "../plugins/index.js";
 
 export function registerCommands(program, registry) {
@@ -18,10 +20,19 @@ export function registerCommands(program, registry) {
 
   program
     .command("login")
-    .description("Authenticate with Claude (OAuth login via browser)")
+    .description("Authenticate with services (Claude, Coda)")
+    .argument("[service]", "Service to login to: claude (default) or coda")
     .option("--no-browser", "Paste API key in terminal instead of OAuth")
-    .action(async (opts) => {
-      await runLogin({ browser: opts.browser });
+    .action(async (service, opts) => {
+      const target = (service || "claude").toLowerCase();
+      if (target === "coda") {
+        await runCodaLogin();
+      } else if (target === "claude") {
+        await runLogin({ browser: opts.browser });
+      } else {
+        console.error(chalk.red(`Unknown service "${target}". Use: claude, coda`));
+        process.exit(1);
+      }
     });
 
   program
@@ -82,9 +93,9 @@ export function registerCommands(program, registry) {
     .action(async (opts) => {
       const root = requireRoot(program);
       if (opts.message) {
-        await runAgentSingleTurn(root, opts.message, { runSuggestions: opts.run !== false, model: opts.model });
+        await runAgentSingleTurn(root, opts.message, { runSuggestions: opts.run !== false, model: opts.model, registry });
       } else {
-        await runAgentInteractive(root);
+        await runAgentInteractive(root, { registry });
       }
     });
 
@@ -95,11 +106,55 @@ export function registerCommands(program, registry) {
     .option("--no-chat", "Skip interactive AI assistant after startup")
     .action(async (opts) => {
       const root = requireRoot(program);
+
+      // Pre-flight: check if project is initialised
+      const initIssue = checkInitState(root);
+      if (initIssue) {
+        console.error(chalk.red(`\n  Project not ready: ${initIssue}.`));
+        console.error(chalk.dim("  Run `fops init` first to set up the project.\n"));
+        process.exit(1);
+      }
+
       await ensureEcrAuth(root);
       await runHook(registry, "before:up", { root });
-      await make(root, "start");
+
+      // Detect stuck containers (restarting / unhealthy) and force-recreate them
+      const forceRecreate = [];
+      try {
+        const { stdout } = await execa("docker", ["compose", "ps", "--format", "json"], {
+          cwd: root, reject: false, timeout: 10000,
+        });
+        if (stdout?.trim()) {
+          for (const line of stdout.trim().split("\n").filter(Boolean)) {
+            try {
+              const svc = JSON.parse(line);
+              const state = (svc.State || "").toLowerCase();
+              const health = (svc.Health || "").toLowerCase();
+              if (state === "restarting" || health === "unhealthy") {
+                forceRecreate.push(svc.Service || svc.Name);
+              }
+            } catch {}
+          }
+        }
+      } catch {}
+
+      if (forceRecreate.length > 0) {
+        console.log(chalk.yellow(`  Recreating stuck containers: ${forceRecreate.join(", ")}`));
+        await dockerCompose(root, ["rm", "-f", "-s", ...forceRecreate]);
+      }
+
+      console.log(chalk.green("  Starting services..."));
+      const result = await dockerCompose(root, ["up", "-d", "--remove-orphans", "--pull", "always"]);
+      // Clear any trailing \r progress line from docker compose output
+      process.stdout.write("\x1b[2K\r");
       await runHook(registry, "after:up", { root });
-      if (opts.chat !== false) await runAgentInteractive(root);
+      if (result.exitCode !== 0) {
+        console.error(chalk.red(`\n  Some services failed to start (exit code ${result.exitCode}).`));
+        console.error(chalk.dim("  Dropping into debug agent to diagnose...\n"));
+        await runAgentInteractive(root, { registry, initialAgent: "debug" });
+        return;
+      }
+      if (opts.chat !== false) await runAgentInteractive(root, { registry });
     });
 
   program
@@ -107,7 +162,7 @@ export function registerCommands(program, registry) {
     .description("Interactive AI assistant (same as foundation agent with no -m)")
     .action(async () => {
       const root = requireRoot(program);
-      await runAgentInteractive(root);
+      await runAgentInteractive(root, { registry });
     });
 
   program
@@ -150,10 +205,28 @@ export function registerCommands(program, registry) {
 
   program
     .command("config")
-    .description("Launch interactive configuration (make config)")
+    .description("Toggle MX_FF_* feature flags and restart affected services")
+    .action(async () => {
+      const root = requireRoot(program);
+      await runFeatureFlags(root);
+    });
+
+  program
+    .command("build")
+    .description("Build all Foundation service images from source")
     .action(async () => {
       const root = requireRoot(program);
-      await make(root, "config");
+      await ensureEcrAuth(root);
+      await make(root, "build");
+    });
+
+  program
+    .command("download")
+    .description("Pull all container images from registry (requires ECR auth)")
+    .action(async () => {
+      const root = requireRoot(program);
+      await ensureEcrAuth(root);
+      await make(root, "download");
     });
 
   program
@@ -183,14 +256,14 @@ export function registerCommands(program, registry) {
     .action(async () => {
       const skills = await loadSkills(registry);
       if (skills.length === 0) {
-        console.log(chalk.gray("  No skills available."));
+        console.log(chalk.dim("  No skills available."));
         return;
       }
       console.log(chalk.bold.cyan("\n  Agent Skills\n"));
       for (const s of skills) {
-        const source = s.pluginId ? chalk.gray(`(plugin: ${s.pluginId})`) : chalk.gray("(built-in)");
+        const source = s.pluginId ? chalk.dim(`(plugin: ${s.pluginId})`) : chalk.dim("(built-in)");
         console.log(`  ${chalk.green("●")} ${chalk.bold(s.name)} ${source}`);
-        if (s.description) console.log(chalk.gray(`    ${s.description}`));
+        if (s.description) console.log(chalk.dim(`    ${s.description}`));
       }
       console.log("");
     });
@@ -205,15 +278,15 @@ export function registerCommands(program, registry) {
     .description("List installed plugins with status")
     .action(async () => {
       if (registry.plugins.length === 0) {
-        console.log(chalk.gray("  No plugins installed."));
-        console.log(chalk.gray("  Install plugins to ~/.fops/plugins/ or via npm (fops-plugin-*)."));
+        console.log(chalk.dim("  No plugins installed."));
+        console.log(chalk.dim("  Install plugins to ~/.fops/plugins/ or via npm (fops-plugin-*)."));
         return;
       }
       console.log(chalk.bold.cyan("\n  Installed Plugins\n"));
       for (const p of registry.plugins) {
-        const source = chalk.gray(`(${p.source})`);
-        console.log(`  ${chalk.green("●")} ${chalk.bold(p.name)} ${chalk.gray("v" + p.version)} ${source}`);
-        console.log(chalk.gray(`    id: ${p.id}  path: ${p.path}`));
+        const source = chalk.dim(`(${p.source})`);
+        console.log(`  ${chalk.green("●")} ${chalk.bold(p.name)} ${chalk.dim("v" + p.version)} ${source}`);
+        console.log(chalk.dim(`    id: ${p.id}  path: ${p.path}`));
       }
       console.log("");
     });

package/src/config.js

@@ -18,7 +18,7 @@ export const CLI_BRAND = {
 export function printFoundationBanner(cwd) {
   const cwdShort = cwd.replace(os.homedir(), "~");
   console.log(chalk.cyan(`  ${CLI_BRAND.title} ${CLI_BRAND.version}`));
-  console.log(chalk.gray(`  ${CLI_BRAND.byline}`));
-  console.log(chalk.gray(`  ${cwdShort}`));
+  console.log(chalk.dim(`  ${CLI_BRAND.byline}`));
+  console.log(chalk.dim(`  ${cwdShort}`));
   console.log("");
 }