@meshxdata/fops 0.0.1

package/src/commands/index.js

@@ -0,0 +1,268 @@
+import fs from "node:fs";
+import os from "node:os";
+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 { 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 { runHook, loadSkills } from "../plugins/index.js";
+
+export function registerCommands(program, registry) {
+  program.name(PKG.name).description("Install and manage Foundation data mesh platforms").version(PKG.version);
+
+  program
+    .command("login")
+    .description("Authenticate with Claude (OAuth login via browser)")
+    .option("--no-browser", "Paste API key in terminal instead of OAuth")
+    .action(async (opts) => {
+      await runLogin({ browser: opts.browser });
+    });
+
+  program
+    .command("setup")
+    .description("Complete automated setup (env, submodules, optional download). Replaces setup.sh.")
+    .option("-d, --dir <path>", "Project directory (default: cwd or FOUNDATION_ROOT)")
+    .option("--no-submodules", "Skip git submodule init/update")
+    .option("--no-env", "Skip .env creation from .env.example")
+    .option("--no-netrc-check", "Skip GitHub .netrc reminder")
+    .option("--download", "Run make download after submodules", false)
+    .option("--yes", "Use defaults without prompting")
+    .action(async (opts) => {
+      const dir = opts.dir ? path.resolve(opts.dir) : (rootDir() || process.cwd());
+      if (!fs.existsSync(path.join(dir, "docker-compose.yaml")) && !fs.existsSync(path.join(dir, "docker-compose.yml"))) {
+        console.error(chalk.red("No docker-compose in %s. Run from foundation-compose root."), dir);
+        process.exit(1);
+      }
+      await runHook(registry, "before:setup", { root: dir });
+      await runSetup(dir, {
+        submodules: opts.submodules !== false,
+        env: opts.env !== false,
+        netrcCheck: opts.netrcCheck !== false,
+        download: opts.download === true,
+      });
+      await runHook(registry, "after:setup", { root: dir });
+    });
+
+  program
+    .command("init")
+    .description("Initialize a Foundation project. Runs an interactive wizard when not in a project root.")
+    .option("-d, --dir <path>", "Project directory (default: cwd or wizard)")
+    .option("--no-submodules", "Skip git submodule init/update")
+    .option("--yes", "Use defaults without prompting; fail if no docker-compose in cwd")
+    .action(async (opts) => {
+      const dir = opts.dir ? path.resolve(opts.dir) : process.cwd();
+      const hasCompose = hasComposeInDir(dir);
+      if (opts.yes) {
+        if (!hasCompose || !fs.existsSync(path.join(dir, "Makefile"))) {
+          console.error(chalk.red("No docker-compose + Makefile in %s. Clone foundation-compose first or run without --yes for the wizard."), dir);
+          process.exit(1);
+        }
+        await runSetup(dir, { submodules: opts.submodules !== false, env: true, netrcCheck: true });
+        return;
+      }
+      if (hasCompose && fs.existsSync(path.join(dir, "Makefile"))) {
+        await runSetup(dir, { submodules: opts.submodules !== false });
+        return;
+      }
+      await runInitWizard();
+    });
+
+  program
+    .command("agent")
+    .description("AI assistant for managing the Foundation stack. Interactive TUI or single-turn with -m.")
+    .option("-m, --message <text>", "Single turn: send message, get reply (uses ANTHROPIC_API_KEY or OPENAI_API_KEY)")
+    .option("--no-run", "Do not offer to run suggested commands (single-turn only)", false)
+    .option("--model <id>", "Model override (e.g. claude-sonnet-4-20250514, gpt-4o-mini)")
+    .action(async (opts) => {
+      const root = requireRoot(program);
+      if (opts.message) {
+        await runAgentSingleTurn(root, opts.message, { runSuggestions: opts.run !== false, model: opts.model });
+      } else {
+        await runAgentInteractive(root);
+      }
+    });
+
+  program
+    .command("up")
+    .description("Start all Foundation services (docker compose up)")
+    .option("-d, --detach", "Run in background", true)
+    .option("--no-chat", "Skip interactive AI assistant after startup")
+    .action(async (opts) => {
+      const root = requireRoot(program);
+      await ensureEcrAuth(root);
+      await runHook(registry, "before:up", { root });
+      await make(root, "start");
+      await runHook(registry, "after:up", { root });
+      if (opts.chat !== false) await runAgentInteractive(root);
+    });
+
+  program
+    .command("chat")
+    .description("Interactive AI assistant (same as foundation agent with no -m)")
+    .action(async () => {
+      const root = requireRoot(program);
+      await runAgentInteractive(root);
+    });
+
+  program
+    .command("down")
+    .description("Stop all Foundation services")
+    .option("--clean", "Remove volumes and orphans (make clean)")
+    .action(async (opts) => {
+      const root = requireRoot(program);
+      await runHook(registry, "before:down", { root });
+      await make(root, opts.clean ? "clean" : "stop");
+      await runHook(registry, "after:down", { root });
+    });
+
+  program
+    .command("status")
+    .description("Show status of Foundation services")
+    .action(async () => {
+      const root = requireRoot(program);
+      await make(root, "status");
+    });
+
+  program
+    .command("logs")
+    .description("Stream logs for all services or a specific service")
+    .argument("[service]", "Service name (e.g. backend, frontend)")
+    .option("-f, --follow", "Follow log output", true)
+    .action(async (service, opts) => {
+      const root = requireRoot(program);
+      if (service) await make(root, `logs-${service}`);
+      else await make(root, "logs");
+    });
+
+  program
+    .command("doctor")
+    .description("Check environment and Foundation setup (Docker, git, .env, submodules)")
+    .option("--fix", "Apply suggested fixes where possible", false)
+    .action(async (opts) => {
+      await runDoctor(opts, registry);
+    });
+
+  program
+    .command("config")
+    .description("Launch interactive configuration (make config)")
+    .action(async () => {
+      const root = requireRoot(program);
+      await make(root, "config");
+    });
+
+  program
+    .command("bootstrap")
+    .description("Create demo data mesh (make bootstrap)")
+    .action(async () => {
+      const root = requireRoot(program);
+      await make(root, "bootstrap");
+    });
+
+  program
+    .command("test")
+    .description("Run health checks (make test)")
+    .action(async () => {
+      const root = requireRoot(program);
+      await make(root, "test");
+    });
+
+  // ── Skill management commands ──────────────────────
+  const skillCmd = program
+    .command("skill")
+    .description("Manage agent skills");
+
+  skillCmd
+    .command("list")
+    .description("List available agent skills")
+    .action(async () => {
+      const skills = await loadSkills(registry);
+      if (skills.length === 0) {
+        console.log(chalk.gray("  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)");
+        console.log(`  ${chalk.green("●")} ${chalk.bold(s.name)} ${source}`);
+        if (s.description) console.log(chalk.gray(`    ${s.description}`));
+      }
+      console.log("");
+    });
+
+  // ── Plugin management commands ─────────────────────
+  const pluginCmd = program
+    .command("plugin")
+    .description("Manage fops plugins");
+
+  pluginCmd
+    .command("list")
+    .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-*)."));
+        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}`));
+      }
+      console.log("");
+    });
+
+  pluginCmd
+    .command("install <source>")
+    .description("Install a plugin from a local path")
+    .action(async (source) => {
+      const srcPath = path.resolve(source);
+      if (!fs.existsSync(srcPath) || !fs.existsSync(path.join(srcPath, "fops.plugin.json"))) {
+        console.error(chalk.red("Source must be a directory with fops.plugin.json"));
+        process.exit(1);
+      }
+
+      let manifest;
+      try {
+        manifest = JSON.parse(fs.readFileSync(path.join(srcPath, "fops.plugin.json"), "utf8"));
+      } catch {
+        console.error(chalk.red("Invalid fops.plugin.json"));
+        process.exit(1);
+      }
+
+      const dest = path.join(os.homedir(), ".fops", "plugins", manifest.id);
+      fs.mkdirSync(dest, { recursive: true });
+
+      const entries = fs.readdirSync(srcPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcFile = path.join(srcPath, entry.name);
+        const destFile = path.join(dest, entry.name);
+        if (entry.isFile()) {
+          fs.copyFileSync(srcFile, destFile);
+        } else if (entry.isDirectory()) {
+          fs.cpSync(srcFile, destFile, { recursive: true });
+        }
+      }
+
+      console.log(chalk.green(`  ✓ Installed plugin "${manifest.id}" to ${dest}`));
+    });
+
+  pluginCmd
+    .command("remove <id>")
+    .description("Remove a plugin from ~/.fops/plugins/")
+    .action(async (id) => {
+      const pluginDir = path.join(os.homedir(), ".fops", "plugins", id);
+      if (!fs.existsSync(pluginDir)) {
+        console.error(chalk.red(`Plugin "${id}" not found in ~/.fops/plugins/`));
+        process.exit(1);
+      }
+      fs.rmSync(pluginDir, { recursive: true, force: true });
+      console.log(chalk.green(`  ✓ Removed plugin "${id}"`));
+    });
+}

package/src/config.js

@@ -0,0 +1,24 @@
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
+export const PKG = { name: pkg.name, version: pkg.version };
+export const CLI_BRAND = {
+  title: "Foundation Operator CLI",
+  version: `v${PKG.version}`,
+  byline: "Foundation Team · meshx",
+};
+
+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("");
+}

package/src/config.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from "vitest";
+import os from "node:os";
+import { PKG, CLI_BRAND, printFoundationBanner } from "./config.js";
+
+describe("config", () => {
+  describe("PKG", () => {
+    it("exports name and version", () => {
+      expect(PKG.name).toBe("@meshxdata/fops");
+      expect(typeof PKG.version).toBe("string");
+      expect(PKG.version).toMatch(/^\d+\.\d+\.\d+/);
+    });
+
+    it("only exposes name and version (no extra fields)", () => {
+      expect(Object.keys(PKG).sort()).toEqual(["name", "version"]);
+    });
+  });
+
+  describe("CLI_BRAND", () => {
+    it("has the expected shape", () => {
+      expect(CLI_BRAND.title).toBe("Foundation Operator CLI");
+      expect(CLI_BRAND.version).toMatch(/^v\d+/);
+      expect(CLI_BRAND.byline).toContain("meshx");
+    });
+
+    it("version matches PKG.version", () => {
+      expect(CLI_BRAND.version).toBe(`v${PKG.version}`);
+    });
+  });
+
+  describe("printFoundationBanner", () => {
+    it("prints CLI info to stdout", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      printFoundationBanner("/tmp/test-project");
+      expect(spy).toHaveBeenCalled();
+      const output = spy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Foundation Operator CLI");
+    });
+
+    it("shortens home dir to ~", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const home = os.homedir();
+      printFoundationBanner(home + "/projects/test");
+      const output = spy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("~/projects/test");
+    });
+
+    it("does not replace ~ when path is not under homedir", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      printFoundationBanner("/opt/data/project");
+      const output = spy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("/opt/data/project");
+      expect(output).not.toContain("~");
+    });
+
+    it("prints version and byline", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      printFoundationBanner("/tmp");
+      const output = spy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain(CLI_BRAND.version);
+      expect(output).toContain("meshx");
+    });
+
+    it("prints a trailing blank line", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      printFoundationBanner("/tmp");
+      // Last call should be empty string (blank line)
+      expect(spy.mock.calls[spy.mock.calls.length - 1][0]).toBe("");
+    });
+  });
+});