@meshxdata/fops 0.0.1 → 0.0.4

package/src/plugins/knowledge.js

@@ -0,0 +1,124 @@
+/**
+ * RAG knowledge orchestrator.
+ * Fans out search queries to all registered knowledge sources,
+ * merges results, enforces token budgets, and caches.
+ */
+
+const MAX_TOTAL_BYTES = 16_384;   // ~4000 tokens
+const MAX_PER_SOURCE_BYTES = 8192;
+const MAX_PER_RESULT_BYTES = 4096;
+const SOURCE_TIMEOUT_MS = 5000;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const CACHE_MAX_ENTRIES = 50;
+
+/** Simple LRU cache keyed by query string. */
+const cache = new Map();
+
+function cacheGet(key) {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.ts > CACHE_TTL_MS) {
+    cache.delete(key);
+    return null;
+  }
+  // Move to end (most-recently used)
+  cache.delete(key);
+  cache.set(key, entry);
+  return entry.value;
+}
+
+function cacheSet(key, value) {
+  // Evict oldest if over capacity
+  if (cache.size >= CACHE_MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    cache.delete(oldest);
+  }
+  cache.set(key, { value, ts: Date.now() });
+}
+
+function truncate(str, maxBytes) {
+  if (str.length <= maxBytes) return str;
+  return str.slice(0, maxBytes - 3) + "...";
+}
+
+/**
+ * Search all registered knowledge sources and return formatted context.
+ * @param {object} registry — plugin registry
+ * @param {string} query — user's message / search query
+ * @returns {string|null} formatted knowledge block or null if no results
+ */
+export async function searchKnowledge(registry, query) {
+  const sources = registry?.knowledgeSources;
+  if (!sources?.length || !query?.trim()) return null;
+
+  const normalizedQuery = query.trim().toLowerCase();
+  const cached = cacheGet(normalizedQuery);
+  if (cached !== null) return cached;
+
+  // Fan out to all sources in parallel with individual timeouts
+  const sourceResults = await Promise.all(
+    sources.map(async (source) => {
+      try {
+        const results = await Promise.race([
+          source.search(query),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error("timeout")), SOURCE_TIMEOUT_MS),
+          ),
+        ]);
+        if (!Array.isArray(results)) return [];
+        return results.map((r) => ({ ...r, _source: source.name }));
+      } catch {
+        // Skip failing sources silently
+        return [];
+      }
+    }),
+  );
+
+  // Flatten and sort by score (descending), then by source order
+  const allResults = sourceResults.flat();
+  if (!allResults.length) {
+    cacheSet(normalizedQuery, null);
+    return null;
+  }
+
+  allResults.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+
+  // Enforce per-source budget
+  const sourceBytes = {};
+  const budgeted = allResults.filter((r) => {
+    const src = r._source;
+    const used = sourceBytes[src] || 0;
+    const content = truncate(r.content || "", MAX_PER_RESULT_BYTES);
+    const size = content.length;
+    if (used + size > MAX_PER_SOURCE_BYTES) return false;
+    sourceBytes[src] = used + size;
+    r._truncatedContent = content;
+    return true;
+  });
+
+  // Enforce total budget and format
+  let totalBytes = 0;
+  const sections = [];
+
+  for (const r of budgeted) {
+    const title = r.title || "Untitled";
+    const source = r._source || "unknown";
+    const url = r.url ? ` (${r.url})` : "";
+    const header = `### [${source}] ${title}${url}`;
+    const content = r._truncatedContent || "";
+    const section = `${header}\n${content}`;
+
+    if (totalBytes + section.length > MAX_TOTAL_BYTES) break;
+    totalBytes += section.length;
+    sections.push(section);
+  }
+
+  if (!sections.length) {
+    cacheSet(normalizedQuery, null);
+    return null;
+  }
+
+  const result = "## Knowledge Base\n\n" + sections.join("\n\n");
+  cacheSet(normalizedQuery, result);
+  return result;
+}

package/src/plugins/loader.js

@@ -1,10 +1,50 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { createRegistry } from "./registry.js";
 import { validateManifest } from "./manifest.js";
 import { discoverPlugins } from "./discovery.js";
 import { createPluginApi } from "./api.js";
+import { loadBuiltinAgents } from "../agent/agents.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Ensure ~/.fops/plugins/node_modules symlinks to the CLI's node_modules.
+ * This lets global plugins resolve bare imports (chalk, execa, inquirer, etc.)
+ * via Node's upward directory walk.
+ */
+function ensurePluginNodeModules() {
+  const cliNodeModules = path.resolve(__dirname, "../../node_modules");
+  const pluginsDir = path.join(os.homedir(), ".fops", "plugins");
+  const link = path.join(pluginsDir, "node_modules");
+
+  if (!fs.existsSync(cliNodeModules)) return;
+  if (!fs.existsSync(pluginsDir)) return;
+
+  try {
+    const stat = fs.lstatSync(link);
+    // Already a symlink — check it points to the right place
+    if (stat.isSymbolicLink()) {
+      const target = fs.readlinkSync(link);
+      if (path.resolve(pluginsDir, target) === cliNodeModules) return;
+      // Stale symlink — remove and recreate
+      fs.unlinkSync(link);
+    } else {
+      // Not a symlink (somehow a real dir) — leave it alone
+      return;
+    }
+  } catch {
+    // Doesn't exist — create it
+  }
+
+  try {
+    fs.symlinkSync(cliNodeModules, link, "junction");
+  } catch {
+    // Non-fatal — plugins that use only node: builtins still work
+  }
+}
 
 /**
  * Parse SKILL.md frontmatter (lightweight, same logic as skills.js).
@@ -37,12 +77,39 @@ function isPluginEnabled(pluginId) {
   return true;
 }
 
+/**
+ * Load built-in plugins from ./builtins/ directory.
+ * Each module must export a register(api) function.
+ */
+async function loadBuiltinPlugins(registry) {
+  const builtinsDir = path.join(__dirname, "builtins");
+  if (!fs.existsSync(builtinsDir)) return;
+
+  const entries = fs.readdirSync(builtinsDir).filter((f) => f.endsWith(".js"));
+  for (const file of entries) {
+    try {
+      const mod = await import(path.join(builtinsDir, file));
+      const plugin = mod.default || mod;
+      if (typeof plugin.register === "function") {
+        const pluginId = `builtin:${path.basename(file, ".js")}`;
+        const api = createPluginApi(pluginId, registry);
+        await plugin.register(api);
+      }
+    } catch (err) {
+      console.error(`  Built-in plugin "${file}" failed to load: ${err.message}`);
+    }
+  }
+}
+
 /**
  * Load and activate all discovered plugins.
  * Returns a populated PluginRegistry.
  */
 export async function loadPlugins() {
+  ensurePluginNodeModules();
   const registry = createRegistry();
+  loadBuiltinAgents(registry);
+  await loadBuiltinPlugins(registry);
   const candidates = discoverPlugins();
 
   for (const candidate of candidates) {

package/src/plugins/registry.js

@@ -10,5 +10,8 @@ export function createRegistry() {
     doctorChecks: [],  // { pluginId, name, fn }
     hooks: [],         // { pluginId, event, handler, priority }
     skills: [],        // { pluginId, name, description, content }
+    knowledgeSources: [], // { pluginId, name, description, search }
+    autoRunPatterns: [], // { pluginId, pattern: string } — commands matching these prefixes auto-execute
+    agents: [],        // { pluginId, name, description, systemPrompt, contextMode }
   };
 }

package/src/project.js

@@ -49,12 +49,31 @@ export function rootDir(cwd = process.cwd()) {
   return null;
 }
 
+/**
+ * Check whether the Foundation project is fully initialised.
+ * Returns null when ready, or a short reason string when not.
+ */
+export function checkInitState(root) {
+  if (!root) return "no project root";
+  if (!fs.existsSync(path.join(root, ".env"))) return "missing .env";
+  // Check that at least one submodule dir has content
+  const markers = ["foundation-backend", "foundation-frontend", "foundation-storage-engine"];
+  const empty = markers.filter((d) => {
+    const dir = path.join(root, d);
+    if (!fs.existsSync(dir)) return true;
+    try { return fs.readdirSync(dir).length === 0; } catch { return true; }
+  });
+  if (empty.length === markers.length) return "submodules not cloned";
+  return null;
+}
+
 export function requireRoot(program) {
   const r = rootDir();
   if (!r) {
     console.error(
-      chalk.red("Not a Foundation project (no docker-compose + Makefile). Run from foundation-compose or set FOUNDATION_ROOT.")
+      chalk.red("Not a Foundation project (no docker-compose + Makefile).")
     );
+    console.error(chalk.dim("  Run `fops init` to set up, or set FOUNDATION_ROOT."));
     program.error({ exitCode: 1 });
   }
   return r;

package/src/setup/aws.js

@@ -32,8 +32,8 @@ export function saveFopsConfig(config) {
  */
 export async function promptAwsSsoConfig() {
   console.log(chalk.cyan("\n  AWS SSO Configuration\n"));
-  console.log(chalk.gray("  We'll set up an AWS CLI profile for ECR image pulls."));
-  console.log(chalk.gray("  You can find these values in your AWS SSO portal.\n"));
+  console.log(chalk.dim("  We'll set up an AWS CLI profile for ECR image pulls."));
+  console.log(chalk.dim("  You can find these values in your AWS SSO portal.\n"));
 
   const answers = await inquirer.prompt([
     {
@@ -143,7 +143,7 @@ export function detectAwsSsoProfiles() {
  */
 function ask(question, defaultVal) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const suffix = defaultVal ? chalk.gray(` (${defaultVal})`) : "";
+  const suffix = defaultVal ? chalk.dim(` (${defaultVal})`) : "";
   return new Promise((resolve) => {
     rl.question(`  ${question}${suffix}: `, (answer) => {
       rl.close();
@@ -164,7 +164,7 @@ export async function ensureSsoConfig() {
   if (/sso_start_url\s*=/.test(content)) return; // already configured
 
   console.log(chalk.cyan("\n  AWS SSO is not configured. Let's set it up.\n"));
-  console.log(chalk.gray("  You can find these values in your AWS SSO portal.\n"));
+  console.log(chalk.dim("  You can find these values in your AWS SSO portal.\n"));
 
   const sessionName = await ask("SSO session name", "meshx");
   const startUrl = await ask("SSO start URL");
@@ -212,7 +212,7 @@ export async function fixAwsSso() {
   }
 
   const profile = profiles[0];
-  console.log(chalk.gray(`  Using AWS profile: ${profile.name}`));
+  console.log(chalk.dim(`  Using AWS profile: ${profile.name}`));
   console.log(chalk.cyan(`  ▶ aws sso login --profile ${profile.name}`));
 
   // Open /dev/tty directly so SSO login gets a real terminal even when
@@ -358,8 +358,8 @@ export async function checkEcrRepos(dir, awsConfig) {
     const missing = neededRepos.filter((r) => !existingRepos.includes(r));
     if (missing.length > 0) {
       console.log(chalk.yellow("\n⚠ These ECR repos are referenced but don't exist (will need local build):"));
-      for (const r of missing) console.log(chalk.gray(`  ✗ ${r}`));
-      console.log(chalk.gray("  These services will be built from source instead.\n"));
+      for (const r of missing) console.log(chalk.dim(`  ✗ ${r}`));
+      console.log(chalk.dim("  These services will be built from source instead.\n"));
     } else {
       console.log(chalk.green("All required ECR repos exist."));
     }

package/src/setup/setup.js

@@ -7,6 +7,9 @@ import inquirer from "inquirer";
 import { make } from "../shell.js";
 import { readFopsConfig, saveFopsConfig, promptAwsSsoConfig, detectEcrRegistry, checkEcrRepos } from "./aws.js";
 
+// TODO: change back to "main" once stack/api is merged
+export const CLONE_BRANCH = "stack/api";
+
 export function runSetup(dir, opts = {}) {
   const submodules = opts.submodules !== false;
   const createEnv = opts.env !== false;
@@ -21,7 +24,7 @@ export function runSetup(dir, opts = {}) {
         fs.copyFileSync(envExample, envPath);
         console.log(chalk.green("Created .env from .env.example. Edit .env with your settings."));
       } else if (fs.existsSync(envPath)) {
-        console.log(chalk.gray(".env already exists."));
+        console.log(chalk.dim(".env already exists."));
       }
     }
     if (netrcCheck) {
@@ -30,23 +33,26 @@ export function runSetup(dir, opts = {}) {
       const hasGitHub = hasNetrc && fs.readFileSync(netrcPath, "utf8").includes("machine github.com");
       if (!hasGitHub) {
         console.log(chalk.yellow("⚠ GitHub: ensure ~/.netrc has credentials for github.com (needed for submodules)."));
-        console.log(chalk.gray("  See README: Configure GitHub Authentication"));
+        console.log(chalk.dim("  See README: Configure GitHub Authentication"));
       }
     }
     if (submodules) {
-      console.log(chalk.blue("Initializing git submodules (checking out main)..."));
+      console.log(chalk.blue(`Initializing git submodules (checking out ${CLONE_BRANCH})...`));
       try {
-        await execa("git", ["submodule", "update", "--init", "--remote", "--recursive"], { cwd: dir, stdio: "inherit" });
-        console.log(chalk.green("Submodules initialized — all on main."));
+        await execa("git", ["submodule", "update", "--init", "--force", "--remote", "--recursive"], { cwd: dir, stdio: "inherit" });
+        // Check out the target branch on each submodule
+        await execa("git", ["submodule", "foreach", `git fetch origin && git checkout origin/${CLONE_BRANCH} 2>/dev/null || git checkout origin/main`], { cwd: dir, stdio: "inherit" });
+        console.log(chalk.green(`Submodules initialized — on ${CLONE_BRANCH} (falling back to main).`));
       } catch {
-        console.log(chalk.yellow("⚠ Some submodules had issues. Attempting to check out main individually..."));
+        console.log(chalk.yellow(`⚠ Some submodules had issues. Attempting to recover individually...`));
         try {
-          await execa("git", ["submodule", "init"], { cwd: dir, stdio: "inherit" });
-          await execa("git", ["submodule", "foreach", "git fetch origin main && git checkout origin/main"], { cwd: dir, stdio: "inherit" });
+          await execa("git", ["submodule", "absorbgitdirs"], { cwd: dir, stdio: "inherit" });
+          await execa("git", ["submodule", "update", "--init", "--force", "--recursive"], { cwd: dir, stdio: "inherit" });
+          await execa("git", ["submodule", "foreach", `git fetch origin && git checkout origin/${CLONE_BRANCH} 2>/dev/null || git checkout origin/main`], { cwd: dir, stdio: "inherit" });
           console.log(chalk.green("Submodules recovered."));
         } catch {
           console.log(chalk.yellow("Some submodules still failed. Fix manually with:"));
-          console.log(chalk.gray(`  cd ${dir} && git submodule foreach 'git checkout main && git pull'`));
+          console.log(chalk.dim(`  cd ${dir} && git submodule foreach 'git checkout ${CLONE_BRANCH} || git checkout main && git pull'`));
         }
       }
     }
@@ -96,7 +102,7 @@ export function runSetup(dir, opts = {}) {
           else fs.writeFileSync(awsConfigPath, ssoConfig, { mode: 0o600 });
           console.log(chalk.green(`  Created AWS profile '${awsConfig.profileName}' in ~/.aws/config`));
         } else {
-          console.log(chalk.gray("  Skipping AWS setup. Private ECR images won't be available."));
+          console.log(chalk.dim("  Skipping AWS setup. Private ECR images won't be available."));
           console.log(chalk.blue("Downloading public container images..."));
           try {
             await make(dir, "download");
@@ -152,8 +158,8 @@ export function runSetup(dir, opts = {}) {
         await make(dir, "download");
       } catch {
         console.log(chalk.yellow("\n⚠ Some images failed to download. Public images are fine."));
-        console.log(chalk.gray(`  For private ECR images, ensure: aws sso login --profile ${awsConfig.profileName}`));
-        console.log(chalk.gray("  Then re-run: fops init --download\n"));
+        console.log(chalk.dim(`  For private ECR images, ensure: aws sso login --profile ${awsConfig.profileName}`));
+        console.log(chalk.dim("  Then re-run: fops init --download\n"));
       }
     }
     console.log(chalk.green("Setup complete. Run: fops up"));

package/src/setup/wizard.js

@@ -5,7 +5,9 @@ import chalk from "chalk";
 import { execa } from "execa";
 import inquirer from "inquirer";
 import { isFoundationRoot, findComposeRootUp } from "../project.js";
-import { runSetup } from "./setup.js";
+import { discoverPlugins } from "../plugins/discovery.js";
+import { validateManifest } from "../plugins/manifest.js";
+import { runSetup, CLONE_BRANCH } from "./setup.js";
 
 export async function runInitWizard() {
   const cwd = process.cwd();
@@ -13,10 +15,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,19 +30,33 @@ export async function runInitWizard() {
       projectRoot = foundUp;
     }
     if (!projectRoot) {
-      let hasGit = false, hasDocker = false, hasAws = false;
+      let hasGit = false, hasDocker = false, hasAws = false, hasClaude = false;
       try { await execa("git", ["--version"]); hasGit = true; } catch {}
       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 {}
       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)"));
       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 {}
+        console.log(cursorVer
+          ? chalk.green("  ✓ Cursor IDE") + chalk.dim(` — ${cursorVer}`)
+          : chalk.yellow("  ⚠ Cursor IDE — install from cursor.com, then: Cmd+Shift+P → 'Install cursor command'"));
+      }
       console.log("");
-      if (!hasGit || !hasDocker) {
+      if (!hasGit || !hasDocker || !hasClaude) {
         console.log(chalk.red("Fix the missing prerequisites above, then run fops init again.\n"));
         process.exit(1);
       }
@@ -55,8 +71,9 @@ export async function runInitWizard() {
         const { repoUrl } = await inquirer.prompt([
           { type: "input", name: "repoUrl", message: "Repository URL:", default: "https://github.com/meshxdata/foundation-compose.git", validate: (v) => (v?.trim() ? true : "Repository URL is required.") },
         ]);
+        const repoName = repoUrl.trim().replace(/\.git$/, "").split("/").pop() || "foundation-compose";
         const { targetDir } = await inquirer.prompt([
-          { type: "input", name: "targetDir", message: "Clone into:", default: cwd },
+          { type: "input", name: "targetDir", message: "Clone into:", default: path.join(cwd, repoName) },
         ]);
         const resolved = path.resolve(targetDir.trim());
         if (fs.existsSync(resolved)) {
@@ -64,9 +81,9 @@ export async function runInitWizard() {
           if (isFoundationRoot(resolved)) { console.log(chalk.green("  Looks like a Foundation project — using it.\n")); projectRoot = resolved; }
           else { console.log(chalk.red("  Not a Foundation project. Remove it or choose a different path.\n")); process.exit(1); }
         } else {
-          console.log(chalk.blue("\nCloning (this may take a minute)...\n"));
+          console.log(chalk.blue(`\nCloning (branch: ${CLONE_BRANCH}, this may take a minute)...\n`));
           try {
-            await execa("git", ["clone", repoUrl.trim(), resolved], { stdio: "inherit" });
+            await execa("git", ["clone", "-b", CLONE_BRANCH, repoUrl.trim(), resolved], { stdio: "inherit" });
           } catch (err) {
             console.log(chalk.red("\n  Clone failed. Check the URL and your credentials.\n"));
             if (!hasNetrc) {
@@ -75,19 +92,21 @@ export async function runInitWizard() {
             }
             process.exit(1);
           }
-          console.log(chalk.blue("\nInitializing submodules (checking out main)...\n"));
+          console.log(chalk.blue(`\nInitializing submodules (checking out ${CLONE_BRANCH})...\n`));
           try {
-            await execa("git", ["submodule", "update", "--init", "--remote", "--recursive"], { cwd: resolved, stdio: "inherit" });
-            console.log(chalk.green("\n  Cloned successfully — all submodules on main.\n"));
+            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 main 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", "foreach", "git fetch origin main && git checkout origin/main"], { 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 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;
@@ -114,6 +133,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/shell.js

@@ -1,9 +1,9 @@
 import { execa } from "execa";
 
 export async function make(root, target, args = []) {
-  return execa("make", [target, ...args], { cwd: root, stdio: "inherit" });
+  return execa("make", [target, ...args], { cwd: root, stdio: "inherit", reject: false });
 }
 
 export async function dockerCompose(root, args) {
-  return execa("docker", ["compose", ...args], { cwd: root, stdio: "inherit" });
+  return execa("docker", ["compose", ...args], { cwd: root, stdio: "inherit", reject: false });
 }