@meshxdata/fops 0.0.1

package/README.md

@@ -0,0 +1,98 @@
+# Foundation CLI
+
+Install and manage **Foundation** data mesh platforms from the terminal.
+
+## Install
+
+**npm / npx (recommended)**
+
+```bash
+# Run without installing
+npx foundation doctor
+
+# Install globally
+npm install -g foundation
+# or
+pnpm add -g foundation
+```
+
+**From repo (development)**
+
+```bash
+cd foundation-compose/foundation-cli
+npm install
+npm link   # optional: use `foundation` from anywhere
+```
+
+**Shell installer (optional)**
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/meshxdata/foundation-compose/main/foundation-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). |
+
+### 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.
+
+**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`  
+
+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`.  
+
+Install optional deps: `npm install @anthropic-ai/sdk openai`.
+
+## 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.
+
+```bash
+cd /path/to/foundation-compose
+foundation doctor
+foundation up
+foundation status
+```
+
+First-time setup:
+
+```bash
+git clone https://github.com/meshxdata/foundation-compose
+cd foundation-compose
+npx foundation init
+npx foundation 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.
+
+## Requirements
+
+- Node.js >= 18
+- Docker (Docker Compose)
+- Git (for `foundation init` submodules)
+
+## License
+
+MIT

package/STRUCTURE.md

@@ -0,0 +1,43 @@
+# Foundation CLI — Project structure
+
+Long-term layout for a single package inside the foundation-compose repo. No git submodules required; the CLI lives in `foundation-cli/` and is versioned with the repo.
+
+## Layout
+
+```
+foundation-cli/
+├── foundation.mjs          # Entry point: parses argv, registers commands, runs
+├── package.json
+├── README.md
+├── STRUCTURE.md            # This file
+├── install.sh              # Optional curl | bash installer
+└── src/
+    ├── config.js           # PKG, CLI_BRAND, printFoundationBanner
+    ├── project.js          # rootDir, requireRoot, isFoundationRoot, findComposeRootUp
+    ├── shell.js            # make(), dockerCompose()
+    ├── auth.js             # resolveAnthropicApiKey, resolveOpenAiApiKey, authHelp, offerClaudeLogin
+    ├── setup.js            # runSetup, runInitWizard, checkEcrRepos
+    ├── agent.js            # gatherStackContext, runAgentSingleTurn, runAgentInteractive, streaming
+    ├── doctor.js           # runDoctor (checks + optional --fix)
+    └── commands/
+        └── index.js       # registerCommands(program) — wires all CLI commands
+```
+
+## Conventions
+
+- **Single entry**: `foundation.mjs` is the only file executed; it imports `src/commands/index.js` and calls `registerCommands(program)`.
+- **No circular imports**: Flow is entry → commands → lib (config, project, shell, auth, setup, agent, doctor). Lib modules do not import commands.
+- **ESM only**: `"type": "module"` in package.json; all sources use `import`/`export`.
+- **Shared helpers**: Project root detection and `make`/docker are in `project.js` and `shell.js` so every command reuses the same semantics.
+
+## Adding a command
+
+1. Implement logic in the appropriate `src/*.js` (or a new one if it’s a new domain).
+2. In `src/commands/index.js`, add a `program.command(...).action(...)` that calls your function and uses `requireRoot(program)` or `rootDir()` as needed.
+
+## Optional: separate repo (submodule)
+
+If you later move the CLI to its own repo and add it as a submodule under `foundation-compose/foundation-cli`:
+
+- Keep this same layout inside the submodule.
+- Root `setup.sh` and docs can still say “run `node foundation-cli/foundation.mjs`” or “`npx foundation`” if the package is published.

package/foundation.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { registerCommands } from "./src/commands/index.js";
+import { loadPlugins } from "./src/plugins/index.js";
+
+const program = new Command();
+const registry = await loadPlugins();
+
+registerCommands(program, registry);
+
+for (const cmd of registry.commands) {
+  cmd.spec(program);
+}
+
+program.parse();

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@meshxdata/fops",
+  "version": "0.0.1",
+  "description": "CLI to install and manage Foundation data mesh platforms",
+  "keywords": [
+    "foundation",
+    "data-mesh",
+    "cli",
+    "installer"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "fops": "./foundation.mjs"
+  },
+  "files": [
+    "foundation.mjs",
+    "src/",
+    "README.md",
+    "STRUCTURE.md"
+  ],
+  "scripts": {
+    "start": "node foundation.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "execa": "^9.5.2",
+    "ink": "^6.7.0",
+    "ink-spinner": "^5.0.0",
+    "inquirer": "^9.2.23",
+    "ora": "^9.3.0",
+    "path-key": "^1.0.0",
+    "react": "^19.2.4"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/sdk": "^0.32.0",
+    "openai": "^4.73.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
+  }
+}

package/src/agent/agent.js

@@ -0,0 +1,367 @@
+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";
+
+/**
+ * Render inline markdown: **bold**, *italic*, `code`
+ */
+function renderInline(line) {
+  return line
+    .replace(/\*\*(.+?)\*\*/g, (_, t) => chalk.bold(t))
+    .replace(/\*(.+?)\*/g, (_, t) => chalk.italic(t))
+    .replace(/`([^`]+)`/g, (_, t) => chalk.yellowBright(t));
+}
+
+/**
+ * Format AI response markdown for the terminal with ⏺ bullet prefix.
+ * Handles headings, bold, italic, inline code, code blocks, lists, blockquotes.
+ */
+export function formatResponse(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let inCode = false;
+  let codeLang = "";
+
+  let codeBlock = [];
+
+  for (const line of lines) {
+    // Code block fences
+    if (/^```/.test(line.trim())) {
+      if (!inCode) {
+        inCode = true;
+        codeLang = line.trim().replace(/^```/, "").trim();
+        codeBlock = [];
+      } else {
+        // Closing fence — render the collected block
+        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) + "┘");
+        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(bot);
+        inCode = false;
+        codeLang = "";
+        codeBlock = [];
+      }
+      continue;
+    }
+
+    // Inside code block — collect lines
+    if (inCode) {
+      codeBlock.push(line);
+      continue;
+    }
+
+    // Headings
+    if (/^#{1,3}\s/.test(line)) {
+      const content = line.replace(/^#{1,3}\s+/, "");
+      out.push(chalk.bold.cyan(content));
+      continue;
+    }
+
+    // Blockquote
+    if (/^>\s?/.test(line)) {
+      const content = line.replace(/^>\s?/, "");
+      out.push(chalk.gray.italic("  " + renderInline(content)));
+      continue;
+    }
+
+    // Unordered list
+    if (/^[\s]*[-*+]\s/.test(line)) {
+      const content = line.replace(/^[\s]*[-*+]\s+/, "");
+      out.push("  " + chalk.cyan("•") + " " + renderInline(content));
+      continue;
+    }
+
+    // Ordered list
+    if (/^[\s]*\d+\.\s/.test(line)) {
+      const match = line.match(/^[\s]*(\d+)\.\s+(.*)/);
+      if (match) {
+        out.push("  " + chalk.cyan(match[1] + ".") + " " + renderInline(match[2]));
+        continue;
+      }
+    }
+
+    // Regular text (or blank line)
+    out.push(renderInline(line));
+  }
+
+  const rendered = out.join("\n").trimEnd();
+  const outputLines = rendered.split("\n");
+  const bullet = chalk.cyan("⏺");
+  return outputLines.map((l, i) => {
+    if (i === 0) return `${bullet} ${l}`;
+    return `  ${l}`;
+  }).join("\n");
+}
+
+export function extractSuggestedCommands(text) {
+  const commands = [];
+  const re = /```(?:bash|sh)\s*\n([\s\S]*?)```/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const block = m[1].trim().split("\n").map((l) => l.replace(/^\s*#.*$/, "").trim()).filter(Boolean);
+    if (block.length) commands.push(block[0]);
+  }
+  return commands;
+}
+
+/**
+ * Run a shell command string, capturing output.
+ * Returns { ok, output } — never throws.
+ */
+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)}`;
+
+  console.log(`\n   ${chalk.gray(branch)} ${chalk.white(trimmed)} ${chalk.gray("· running")}`);
+
+  try {
+    // Pipe stdout/stderr so docker/compose use clean non-TTY output
+    // (no multi-line progress bars). Inherit stdin for interactive prompts.
+    const proc = execa("sh", ["-c", trimmed], {
+      cwd: root,
+      stdio: ["inherit", "pipe", "pipe"],
+      reject: false,
+      timeout: 120_000,
+    });
+
+    let output = "";
+    let lastWasCR = false;
+
+    const streamChunk = (chunk) => {
+      const text = chunk.toString();
+      output += text;
+      for (const raw of text.split("\n")) {
+        if (!raw) continue;
+        // Handle \r progress bars — overwrite previous line
+        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)}`);
+        lastWasCR = raw.includes("\r") && !raw.endsWith("\n");
+        if (!lastWasCR) process.stdout.write("\n");
+      }
+    };
+
+    proc.stdout.on("data", streamChunk);
+    proc.stderr.on("data", streamChunk);
+
+    const result = await proc;
+    if (lastWasCR) process.stdout.write("\n");
+
+    if (result.exitCode !== 0) {
+      console.log(`${prefix}${chalk.yellow("⚠ Exit code " + result.exitCode)}`);
+      return { ok: false, output: output || `Exit code ${result.exitCode}` };
+    }
+    console.log(`${prefix}${chalk.green("✓ Done")}`);
+    return { ok: true, output };
+  } catch (err) {
+    const msg = err.message || String(err);
+    console.log(`${prefix}${chalk.red("✗ " + msg)}`);
+    return { ok: false, output: msg };
+  }
+}
+
+/**
+ * Present suggested commands in a single picker.
+ * Shows each command as a selectable option plus "Run all" / "Skip".
+ * Returns array of { command, ok, output } for commands that were run.
+ */
+export async function askToRunCommand(root, replyText) {
+  const suggested = extractSuggestedCommands(replyText);
+  if (suggested.length === 0) return [];
+
+  console.log(chalk.cyan("⏺") + chalk.white(" Suggested commands:"));
+
+  const options = suggested.map((cmd) => ({ label: cmd, value: cmd }));
+  if (suggested.length > 1) {
+    options.push({ label: "Run all", value: "__run_all__" });
+  }
+  options.push({ label: "Skip", value: "__skip__" });
+
+  const choice = await selectOption("Run command?", options);
+
+  if (choice === null || choice === "__skip__") return [];
+
+  const toRun = choice === "__run_all__" ? suggested : [choice];
+  const results = [];
+
+  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;
+}
+
+export async function runAgentSingleTurn(root, message, opts = {}) {
+  const runSuggestions = opts.runSuggestions !== false;
+  const useClaudeCode = hasClaudeCode() && hasClaudeCodeAuth();
+  const anthropicKey = resolveAnthropicApiKey();
+  const openaiKey = resolveOpenAiApiKey();
+
+  if (!useClaudeCode && !anthropicKey && !openaiKey) {
+    authHelp();
+    process.exit(1);
+  }
+
+  const context = await gatherStackContext(root);
+  const systemContent = FOUNDATION_SYSTEM_PROMPT + "\n\n" + context;
+  let replyText = "";
+
+  const spinner = renderSpinner();
+
+  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 ?? "";
+    }
+  } 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);
+    }
+    const msg = String(err?.message ?? err?.body ?? "");
+    if (err?.status === 401 || msg.includes("401") || msg.includes("authentication_error") || msg.includes("invalid x-api-key")) {
+      console.log(chalk.red("Authentication failed: invalid or expired API key."));
+      const didLogin = await offerClaudeLogin();
+      if (didLogin) {
+        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"));
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  spinner.stop();
+  console.log("");
+  console.log(formatResponse(replyText));
+  console.log("");
+
+  if (runSuggestions) {
+    const cmdResults = await askToRunCommand(root, replyText);
+    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) {
+  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"));
+    process.exit(1);
+  }
+
+  if (!useClaudeCode) {
+    try {
+      await import("@anthropic-ai/sdk");
+    } catch (e) {
+      if (e.code === "MODULE_NOT_FOUND") {
+        console.log(chalk.yellow("Install optional deps: npm install @anthropic-ai/sdk openai\n"));
+        process.exit(1);
+      }
+    }
+  }
+
+  const context = await gatherStackContext(root);
+  const systemContent = FOUNDATION_SYSTEM_PROMPT + "\n\n" + context;
+  const messages = [];
+
+  // Show banner
+  renderBanner();
+
+  // Show quick hints
+  console.log(chalk.gray("  Try: \"help me set up\" • \"what's running?\" • \"show logs\" • \"run diagnostics\"\n"));
+
+  // Main chat loop
+  while (true) {
+    const input = await promptInput();
+
+    // Exit on null (esc/ctrl+c) or exit command
+    if (input === null || /^\/(exit|quit|q)$/i.test(input)) {
+      console.log(chalk.gray("\nGoodbye!\n"));
+      break;
+    }
+
+    if (!input.trim()) continue;
+
+    messages.push({ role: "user", content: input });
+
+    try {
+      const replyText = await streamAssistantReply(root, messages, systemContent, {});
+      console.log("");
+      console.log(formatResponse(replyText));
+      console.log("");
+      messages.push({ role: "assistant", content: replyText });
+
+      const cmdResults = await askToRunCommand(root, replyText);
+      // Feed command outputs back into context so the AI knows what happened
+      if (cmdResults.length > 0) {
+        const summary = cmdResults.map((r) =>
+          `[Ran: ${r.command}] ${r.ok ? "Success" : "Failed"}:\n${r.output || "(no output)"}`
+        ).join("\n\n");
+        messages.push({ role: "user", content: `[Command results]\n${summary}` });
+
+        // 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));
+          console.log("");
+          messages.push({ role: "assistant", content: followUp });
+        }
+      }
+    } catch (err) {
+      const msg = String(err?.message ?? err?.body ?? "");
+      const is401 = err?.status === 401 || err?.response?.status === 401 ||
+        msg.includes("401") || msg.includes("authentication_error") || msg.includes("invalid x-api-key");
+      if (is401) {
+        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.red("\nError:"), err.message);
+      }
+    }
+  }
+}