@meshxdata/fops 0.0.3 → 0.0.5

package/src/setup/wizard.js

@@ -5,7 +5,63 @@ import chalk from "chalk";
 import { execa } from "execa";
 import inquirer from "inquirer";
 import { isFoundationRoot, findComposeRootUp } from "../project.js";
+import { discoverPlugins } from "../plugins/discovery.js";
+import { validateManifest } from "../plugins/manifest.js";
 import { runSetup, CLONE_BRANCH } from "./setup.js";
+import { confirm } from "../ui/index.js";
+
+/**
+ * Ensure Homebrew is available (macOS). Installs if missing.
+ */
+async function ensureBrew() {
+  try { await execa("brew", ["--version"]); return true; } catch {}
+  console.log(chalk.cyan("  ▶ Installing Homebrew…"));
+  try {
+    await execa("bash", ["-c", 'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'], {
+      stdio: "inherit", timeout: 300_000,
+    });
+    const brewPaths = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"];
+    for (const bp of brewPaths) {
+      if (fs.existsSync(bp)) { process.env.PATH = path.dirname(bp) + ":" + process.env.PATH; break; }
+    }
+    return true;
+  } catch { return false; }
+}
+
+/**
+ * Try to install a missing tool. Returns true if installed successfully.
+ */
+async function installTool(name, { brew, brewCask, winget, apt, npm: npmPkg } = {}) {
+  const shouldInstall = await confirm(`  Install ${name}?`, true);
+  if (!shouldInstall) return false;
+  try {
+    if (process.platform === "darwin" && (brew || brewCask)) {
+      if (!(await ensureBrew())) { console.log(chalk.red("  Homebrew required")); return false; }
+      const cmd = brewCask ? ["install", "--cask", brewCask] : ["install", brew];
+      console.log(chalk.cyan(`  ▶ brew ${cmd.join(" ")}`));
+      await execa("brew", cmd, { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+    if (process.platform === "win32" && winget) {
+      console.log(chalk.cyan(`  ▶ winget install ${winget}`));
+      await execa("winget", ["install", winget, "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+    if (process.platform === "linux" && apt) {
+      console.log(chalk.cyan(`  ▶ sudo apt-get install -y ${apt}`));
+      await execa("sudo", ["apt-get", "install", "-y", apt], { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+    if (npmPkg) {
+      console.log(chalk.cyan(`  ▶ npm install`));
+      await execa("npm", ["install"], { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+  } catch (err) {
+    console.log(chalk.red(`  Failed to install ${name}: ${err.message}`));
+  }
+  return false;
+}
 
 export async function runInitWizard() {
   const cwd = process.cwd();
@@ -13,10 +69,10 @@ export async function runInitWizard() {
   let projectRoot = null;
   if (envRoot && fs.existsSync(envRoot) && isFoundationRoot(envRoot)) {
     projectRoot = path.resolve(envRoot);
-    console.log(chalk.gray(`Using FOUNDATION_ROOT: ${projectRoot}\n`));
+    console.log(chalk.dim(`Using FOUNDATION_ROOT: ${projectRoot}\n`));
   } else if (isFoundationRoot(cwd)) {
     projectRoot = cwd;
-    console.log(chalk.gray("Using current directory as project root.\n"));
+    console.log(chalk.dim("Using current directory as project root.\n"));
   } else {
     const foundUp = findComposeRootUp(cwd);
     if (foundUp && foundUp !== cwd) {
@@ -28,22 +84,93 @@ export async function runInitWizard() {
       projectRoot = foundUp;
     }
     if (!projectRoot) {
-      let hasGit = false, hasDocker = false, hasAws = false, hasClaude = false;
-      try { await execa("git", ["--version"]); hasGit = true; } catch {}
+      // ── Check prerequisites and offer to install missing ones ──
+      const getVer = async (cmd, args = ["--version"]) => {
+        try { const { stdout } = await execa(cmd, args, { reject: false, timeout: 5000 }); return stdout?.split("\n")[0]?.trim() || null; } catch { return null; }
+      };
+
+      let hasGit = !!(await getVer("git"));
+      let hasDocker = false;
       try { await execa("docker", ["info"], { timeout: 5000 }); hasDocker = true; } catch {}
-      try { await execa("aws", ["--version"]); hasAws = true; } catch {}
-      try { await execa("claude", ["--version"]); hasClaude = true; } catch {}
+      let hasAws = !!(await getVer("aws"));
+      let hasClaude = !!(await getVer("claude"));
+      let hasOp = !!(await getVer("op"));
+
       console.log(chalk.cyan("  Prerequisites\n"));
-      console.log(hasGit ? chalk.green("  ✓ Git") : chalk.red("  ✗ Git — install git first"));
-      console.log(hasDocker ? chalk.green("  ✓ Docker") : chalk.red("  ✗ Docker — install and start Docker Desktop"));
-      console.log(hasClaude ? chalk.green("  ✓ Claude CLI") : chalk.red("  ✗ Claude CLI — run: npm install (included as a dependency)"));
-      console.log(hasAws ? chalk.green("  ✓ AWS CLI") : chalk.yellow("  ⚠ AWS CLI — install for ECR image pulls (brew install awscli)"));
+
+      // Git
+      if (hasGit) console.log(chalk.green("  ✓ Git"));
+      else {
+        console.log(chalk.red("  ✗ Git"));
+        hasGit = await installTool("Git", { brew: "git", winget: "Git.Git", apt: "git" });
+      }
+
+      // Docker
+      if (hasDocker) console.log(chalk.green("  ✓ Docker"));
+      else {
+        console.log(chalk.red("  ✗ Docker"));
+        hasDocker = await installTool("Docker Desktop", { brewCask: "docker", winget: "Docker.DockerDesktop" });
+        if (hasDocker && process.platform === "darwin") {
+          console.log(chalk.cyan("  ▶ open -a Docker"));
+          await execa("open", ["-a", "Docker"], { timeout: 10000 }).catch(() => {});
+        }
+      }
+
+      // Claude CLI
+      if (hasClaude) console.log(chalk.green("  ✓ Claude CLI"));
+      else {
+        console.log(chalk.red("  ✗ Claude CLI"));
+        hasClaude = await installTool("Claude CLI", { npm: true });
+      }
+
+      // AWS CLI (optional)
+      if (hasAws) console.log(chalk.green("  ✓ AWS CLI"));
+      else {
+        console.log(chalk.yellow("  ⚠ AWS CLI") + chalk.dim(" — needed for ECR image pulls"));
+        hasAws = await installTool("AWS CLI", { brew: "awscli", winget: "Amazon.AWSCLI" });
+      }
+
+      // 1Password CLI (optional)
+      if (hasOp) console.log(chalk.green("  ✓ 1Password CLI"));
+      else {
+        console.log(chalk.yellow("  ⚠ 1Password CLI") + chalk.dim(" — needed for secret sync"));
+        hasOp = await installTool("1Password CLI", { brewCask: "1password-cli", winget: "AgileBits.1Password.CLI" });
+      }
+
+      // GitHub credentials
       const netrcPath = path.join(os.homedir(), ".netrc");
       const hasNetrc = fs.existsSync(netrcPath) && fs.readFileSync(netrcPath, "utf8").includes("machine github.com");
       console.log(hasNetrc ? chalk.green("  ✓ GitHub credentials (~/.netrc)") : chalk.yellow("  ⚠ GitHub credentials — add to ~/.netrc (needed for private submodules)"));
+
+      // Cursor IDE (only when cursor plugin is installed)
+      const cursorPluginDir = path.join(os.homedir(), ".fops", "plugins", "cursor");
+      if (fs.existsSync(cursorPluginDir)) {
+        let cursorVer = null;
+        try {
+          const { stdout } = await execa("cursor", ["--version"]);
+          cursorVer = (stdout || "").split("\n")[0].trim();
+        } catch {}
+
+        if (cursorVer) {
+          console.log(chalk.green("  ✓ Cursor IDE") + chalk.dim(` — ${cursorVer}`));
+        } else {
+          // Check if Cursor app is installed even without CLI command
+          const appInstalled = process.platform === "darwin"
+            ? fs.existsSync("/Applications/Cursor.app")
+            : process.platform === "win32"
+              ? fs.existsSync(path.join(os.homedir(), "AppData", "Local", "Programs", "Cursor", "Cursor.exe"))
+              : false;
+          if (appInstalled) {
+            console.log(chalk.green("  ✓ Cursor IDE") + chalk.dim(" — app installed (CLI not in PATH — Cmd+Shift+P → 'Install cursor command' to enable)"));
+          } else {
+            console.log(chalk.yellow("  ⚠ Cursor IDE — install from cursor.com, then: Cmd+Shift+P → 'Install cursor command'"));
+          }
+        }
+      }
+
       console.log("");
       if (!hasGit || !hasDocker || !hasClaude) {
-        console.log(chalk.red("Fix the missing prerequisites above, then run fops init again.\n"));
+        console.log(chalk.red("  Required tools are still missing. Install them and run fops init again.\n"));
         process.exit(1);
       }
       const choices = [
@@ -80,18 +207,19 @@ export async function runInitWizard() {
           }
           console.log(chalk.blue(`\nInitializing submodules (checking out ${CLONE_BRANCH})...\n`));
           try {
-            await execa("git", ["submodule", "update", "--init", "--remote", "--recursive"], { cwd: resolved, stdio: "inherit" });
+            await execa("git", ["submodule", "update", "--init", "--force", "--remote", "--recursive"], { cwd: resolved, stdio: "inherit" });
             await execa("git", ["submodule", "foreach", `git fetch origin && git checkout origin/${CLONE_BRANCH} 2>/dev/null || git checkout origin/main`], { cwd: resolved, stdio: "inherit" });
             console.log(chalk.green(`\n  Cloned successfully — submodules on ${CLONE_BRANCH} (falling back to main).\n`));
           } catch {
-            console.log(chalk.yellow(`\n  ⚠ Some submodules had issues. Attempting to check out ${CLONE_BRANCH} individually...\n`));
+            console.log(chalk.yellow(`\n  ⚠ Some submodules had issues. Attempting to recover...\n`));
             try {
-              await execa("git", ["submodule", "init"], { cwd: resolved, stdio: "inherit" });
+              await execa("git", ["submodule", "absorbgitdirs"], { cwd: resolved, stdio: "inherit" });
+              await execa("git", ["submodule", "update", "--init", "--force", "--recursive"], { cwd: resolved, stdio: "inherit" });
               await execa("git", ["submodule", "foreach", `git fetch origin && git checkout origin/${CLONE_BRANCH} 2>/dev/null || git checkout origin/main`], { cwd: resolved, stdio: "inherit" });
               console.log(chalk.green("  Submodules recovered.\n"));
             } catch {
               console.log(chalk.yellow("  Some submodules still failed. Fix manually with:"));
-              console.log(chalk.gray(`  cd ${resolved} && git submodule foreach 'git checkout ${CLONE_BRANCH} || git checkout main && git pull'\n`));
+              console.log(chalk.dim(`  cd ${resolved} && git submodule foreach 'git checkout ${CLONE_BRANCH} || git checkout main && git pull'\n`));
             }
           }
           projectRoot = resolved;
@@ -118,6 +246,58 @@ export async function runInitWizard() {
     { type: "confirm", name: "env", message: "Create .env from .env.example (if missing)?", default: true },
     { type: "confirm", name: "download", message: "Download container images now (make download)?", default: false },
   ]);
+
+  // ── Plugin selection ───────────────────────────────
+  const candidates = discoverPlugins();
+  const plugins = candidates
+    .map((c) => {
+      const manifest = validateManifest(c.path);
+      if (!manifest) return null;
+      return { id: manifest.id, name: manifest.name, description: manifest.description || "", path: c.path };
+    })
+    .filter(Boolean);
+
+  if (plugins.length > 0) {
+    console.log(chalk.cyan("\n  Plugins\n"));
+    console.log(chalk.dim("  Select which plugins to enable:\n"));
+
+    // Read existing config to preserve current enabled state
+    const fopsConfigPath = path.join(os.homedir(), ".fops.json");
+    let fopsConfig = {};
+    try {
+      if (fs.existsSync(fopsConfigPath)) {
+        fopsConfig = JSON.parse(fs.readFileSync(fopsConfigPath, "utf8"));
+      }
+    } catch {}
+
+    const currentEntries = fopsConfig?.plugins?.entries || {};
+    const choices = plugins.map((p) => {
+      const isEnabled = currentEntries[p.id]?.enabled !== false;
+      return {
+        name: `${p.name}${p.description ? chalk.dim(` — ${p.description}`) : ""}`,
+        value: p.id,
+        checked: isEnabled,
+      };
+    });
+
+    const { enabledPlugins } = await inquirer.prompt([{
+      type: "checkbox",
+      name: "enabledPlugins",
+      message: "Plugins:",
+      choices,
+    }]);
+
+    // Save enabled/disabled state
+    if (!fopsConfig.plugins) fopsConfig.plugins = {};
+    if (!fopsConfig.plugins.entries) fopsConfig.plugins.entries = {};
+    for (const p of plugins) {
+      if (!fopsConfig.plugins.entries[p.id]) fopsConfig.plugins.entries[p.id] = {};
+      fopsConfig.plugins.entries[p.id].enabled = enabledPlugins.includes(p.id);
+    }
+    fs.writeFileSync(fopsConfigPath, JSON.stringify(fopsConfig, null, 2) + "\n");
+    console.log(chalk.green(`  ✓ ${enabledPlugins.length}/${plugins.length} plugin(s) enabled`));
+  }
+
   console.log("");
   await runSetup(projectRoot, { submodules, env, download, netrcCheck: true });
 }

package/src/ui/confirm.js

@@ -50,8 +50,9 @@ export function SelectPrompt({ message, options, onResult }) {
     ),
     ...options.map((opt, i) =>
       h(Box, { key: i },
-        h(Text, { color: i === cursor ? "cyan" : "gray" },
-          `  ${i === cursor ? "❯" : " "} ${opt.label}`
+        h(Text, { color: "cyan" }, i === cursor ? "  ❯ " : "    "),
+        h(Text, { color: i === cursor ? "white" : undefined, dimColor: i !== cursor },
+          opt.label
         )
       )
     )

package/src/ui/input.js

@@ -84,7 +84,7 @@ export function InputBox({ onSubmit, onExit, history = [], statusText }) {
       h(Text, { color: "cyan" }, cursor)
     ),
     h(Separator),
-    statusText && h(Text, { dimColor: true }, "  " + statusText)
+    statusText && h(Text, { color: "#888888" }, "  " + statusText)
   );
 }
 
@@ -161,7 +161,7 @@ export function StandaloneInput({ onResult, statusText }) {
       h(Text, { color: "cyan" }, cursor)
     ),
     h(Separator),
-    statusText && h(Text, { dimColor: true }, "  " + statusText)
+    statusText && h(Text, { color: "#888888" }, "  " + statusText)
   );
 }
 

package/src/ui/spinner.js

@@ -6,7 +6,7 @@ const h = React.createElement;
 
 const SPARKLE_FRAMES = ["✻", "✼", "✻", "✦"];
 const SPARKLE_INTERVAL = 120;
-const INTENT_LINE = chalk.cyan("⏺") + chalk.gray(" Thinking...");
+const INTENT_LINE = chalk.cyan("⏺") + chalk.dim(" Thinking...");
 
 // Claude-style verbs for the spinner
 export const VERBS = [
@@ -55,11 +55,11 @@ export function ThinkingSpinner({ message }) {
   return h(Box, { flexDirection: "column" },
     h(Box, null,
       h(Text, { color: "cyan" }, "⏺"),
-      h(Text, { color: "gray" }, " Thinking...")
+      h(Text, { dimColor: true }, " Thinking...")
     ),
     h(Box, null,
       h(Text, { color: "magenta" }, SPARKLE_FRAMES[frame]),
-      h(Text, { color: "gray" }, ` ${message || `${verb}…`} `),
+      h(Text, { dimColor: true }, ` ${message || `${verb}…`} `),
       h(Text, { dimColor: true }, "(esc to interrupt)")
     )
   );
@@ -134,7 +134,7 @@ function ThinkingDisplay({ status, detail, thinking, content }) {
     ),
     // Response content preview
     contentPreview && h(Box, { marginLeft: 2 },
-      h(Text, { color: "gray" }, contentPreview)
+      h(Text, { dimColor: true }, contentPreview)
     )
   );
 }

package/src/ui/streaming.js

@@ -11,7 +11,7 @@ export function ResponseBox({ content, title = "Claude" }) {
   return h(Box, {
     flexDirection: "column",
     borderStyle: "round",
-    borderColor: "gray",
+    borderColor: "white",
     paddingX: 1,
     marginY: 1,
   },
@@ -64,7 +64,7 @@ export function StreamingResponse({ title = "Claude" }) {
   return h(Box, {
     flexDirection: "column",
     borderStyle: "round",
-    borderColor: "gray",
+    borderColor: "white",
     paddingX: 1,
     marginTop: 1,
   },