multiclaw 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,38 +1,422 @@
 #!/usr/bin/env node
+
+// src/index.ts
 import { Command } from "commander";
-import { runCommand } from "./commands/run";
-import { initCommand } from "./commands/init";
-import { serveCommand } from "./commands/serve";
-import { upgradeCommand } from "./commands/upgrade";
-const program = new Command();
-program
-    .name("multiclaw")
-    .description("Multi-agent orchestration CLI")
-    .version("0.1.0");
-program
-    .command("init")
-    .description("Scaffold a config file (interactive)")
-    .action(() => initCommand());
-program
-    .command("run <requirement>")
-    .description("Run an orchestration")
-    .option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)")
-    .option("--ui", "Start Dashboard and open in browser")
-    .option("--port <port>", "Dashboard port (requires --ui)", (v) => parseInt(v, 10))
-    .option("--server-url <url>", "Connect to a running serve process")
-    .option("--no-leader", "Skip the leader agent and use the default pipeline")
-    .action((requirement, opts) => runCommand(requirement, opts));
-program
-    .command("serve")
-    .description("Start a persistent Dashboard server")
-    .option("--port <port>", "Port", (v) => parseInt(v, 10))
-    .action((opts) => serveCommand(opts));
-program
-    .command("upgrade")
-    .description("Upgrade multiclaw to the latest version")
-    .action(() => upgradeCommand());
-program.parseAsync(process.argv).catch((err) => {
-    console.error(`\x1b[31mError: ${err.message ?? err}\x1b[0m`);
+import { readFileSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/run.ts
+import * as path3 from "path";
+import { Orchestrator as OrchestratorImpl, runtimeRegistry } from "@multiclawcli/core";
+
+// src/loader/loadConfig.ts
+import * as path from "path";
+import * as fs from "fs";
+var DEFAULT_CONFIG_NAMES = ["multiclaw.config.ts", "multiclaw.config.js"];
+function findConfig(configPath) {
+  if (configPath) {
+    const abs = path.resolve(process.cwd(), configPath);
+    if (!fs.existsSync(abs)) throw new Error(`Config file not found: ${abs}`);
+    return abs;
+  }
+  for (const name of DEFAULT_CONFIG_NAMES) {
+    const abs = path.resolve(process.cwd(), name);
+    if (fs.existsSync(abs)) return abs;
+  }
+  throw new Error(`No config file found. Create multiclaw.config.ts in the current directory or use --config to specify a path.`);
+}
+async function loadConfig(configPath, requirement) {
+  const absPath = findConfig(configPath);
+  const { register } = await import("tsx/esm/api");
+  const unregister = register();
+  let mod;
+  try {
+    mod = await import(absPath);
+  } finally {
+    unregister();
+  }
+  const config = mod.default ?? mod.config;
+  if (!config || !Array.isArray(config.agents)) {
+    throw new Error(`Invalid config format \u2014 expected: export default defineConfig({...})`);
+  }
+  const configDir = path.dirname(absPath);
+  config.workDir = path.resolve(configDir, config.workDir);
+  if (requirement !== void 0) {
+    config.context = { ...config.context, requirement };
+  }
+  return config;
+}
+
+// src/reporters/ConsoleReporter.ts
+var isFancy = !process.env.NO_COLOR && process.env.TERM !== "dumb" && process.stdout.isTTY === true;
+var S = isFancy ? { ok: "\u2713", fail: "\u2717", run: "\u203A", retry: "\u21BB", skip: "\u2298", warn: "\u26A0", bullet: "\xB7" } : { ok: "+", fail: "x", run: ">", retry: "~", skip: "-", warn: "!", bullet: "*" };
+var C = isFancy ? {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  purple: "\x1B[35m"
+} : {
+  reset: "",
+  bold: "",
+  dim: "",
+  cyan: "",
+  green: "",
+  yellow: "",
+  red: "",
+  purple: ""
+};
+var ConsoleReporter = class {
+  attach(eventBus) {
+    return eventBus.subscribe((e) => this.handle(e));
+  }
+  handle(e) {
+    switch (e.type) {
+      case "orchestration:start": {
+        const line = (isFancy ? "\u2550" : "=").repeat(50);
+        const edge = isFancy ? ["\u2554", "\u2551", "\u255A", "\u2557", "\u255D"] : ["+", "|", "+", "+", "+"];
+        console.log(`
+${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
+        console.log(`${edge[1]}  ${S.run} ${e.payload.name.padEnd(46)}${edge[1]}`);
+        console.log(`${edge[2]}${line}${edge[4]}${C.reset}`);
+        console.log(`${C.cyan}${S.bullet} Agents: ${e.payload.totalAgents}  Stages: ${e.payload.stages.length}${C.reset}
+`);
+        break;
+      }
+      case "stage:start": {
+        const dash = (isFancy ? "\u2500" : "-").repeat(16);
+        console.log(`${C.cyan}${dash} Stage ${e.payload.stageIndex + 1} ${dash}${C.reset}`);
+        break;
+      }
+      case "agent:start": {
+        console.log(`${C.purple}${S.run} [${e.payload.agentName}] starting...${C.reset}`);
+        break;
+      }
+      case "agent:output": {
+        process.stdout.write(`  ${e.payload.chunk}`);
+        break;
+      }
+      case "agent:complete": {
+        const d = (e.payload.duration / 1e3).toFixed(1);
+        console.log(`${C.green}${S.ok} ${e.payload.agentName} done (${d}s)${C.reset}`);
+        break;
+      }
+      case "agent:failed": {
+        console.log(`${C.red}${S.fail} ${e.payload.agentName} failed: ${e.payload.error}${C.reset}`);
+        break;
+      }
+      case "agent:skipped": {
+        console.log(`${C.yellow}${S.skip} ${e.payload.agentName} skipped${C.reset}`);
+        break;
+      }
+      case "agent:retrying": {
+        console.log(`${C.yellow}${S.retry} ${e.payload.agentName} retry ${e.payload.attempt}/${e.payload.maxAttempts}: ${e.payload.error}${C.reset}`);
+        break;
+      }
+      case "orchestration:complete": {
+        const { success, totalDuration, agentResults } = e.payload;
+        const line = (isFancy ? "\u2550" : "=").repeat(50);
+        const edge = isFancy ? ["\u2554", "\u2551", "\u255A", "\u2557", "\u255D"] : ["+", "|", "+", "+", "+"];
+        const title = success ? `${S.ok} All done` : `${S.warn} Done (with failures)`;
+        console.log(`
+${C.bold}${C.purple}${edge[0]}${line}${edge[3]}`);
+        console.log(`${edge[1]}  ${title.padEnd(48)}${edge[1]}`);
+        console.log(`${edge[2]}${line}${edge[4]}${C.reset}`);
+        const nameWidth = Math.max(8, ...agentResults.map((r) => r.agentName.length));
+        const totalStr = `${(totalDuration / 1e3).toFixed(1)}s`;
+        console.log(`  ~ ${"Total".padEnd(nameWidth)}   ${totalStr.padStart(7)}`);
+        for (const r of agentResults) {
+          const icon = r.status === "success" ? S.ok : S.fail;
+          const color = r.status === "success" ? C.green : C.red;
+          const dur = `${(r.duration / 1e3).toFixed(1)}s`;
+          console.log(`  ${color}${icon}${C.reset} ${r.agentName.padEnd(nameWidth)}   ${dur.padStart(7)}`);
+        }
+        console.log();
+        break;
+      }
+    }
+  }
+};
+
+// src/reporters/FileLogWriter.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var FileLogWriter = class {
+  constructor(logDir) {
+    this.logDir = logDir;
+    this.streams = /* @__PURE__ */ new Map();
+    fs2.mkdirSync(logDir, { recursive: true });
+  }
+  attach(eventBus) {
+    return eventBus.subscribe((e) => this.handle(e));
+  }
+  handle(e) {
+    if (e.type === "agent:output") {
+      this.getStream(e.payload.agentId).write(e.payload.chunk);
+    }
+    if (e.type === "orchestration:complete") {
+      fs2.writeFileSync(
+        path2.join(this.logDir, "report.json"),
+        JSON.stringify(e.payload, null, 2)
+      );
+      this.closeAll();
+    }
+  }
+  getStream(agentId) {
+    if (!this.streams.has(agentId)) {
+      this.streams.set(
+        agentId,
+        fs2.createWriteStream(path2.join(this.logDir, `${agentId}.log`))
+      );
+    }
+    return this.streams.get(agentId);
+  }
+  closeAll() {
+    for (const s of this.streams.values()) s.end();
+    this.streams.clear();
+  }
+};
+
+// src/commands/run.ts
+async function runCommand(requirement, options) {
+  const config = await loadConfig(options.config, requirement);
+  if (options.noLeader) {
+    config.useLeader = false;
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  config.workDir = path3.join(config.workDir, ".multiclaw", "runs", `run-${ts}`);
+  const runtimeNames = new Set(config.agents.map((a) => a.runtime ?? "claude"));
+  for (const name of runtimeNames) {
+    let rt;
+    try {
+      rt = runtimeRegistry.get(name);
+    } catch {
+      console.error(`\x1B[31mError: Unknown runtime "${name}". Supported: claude\x1B[0m`);
+      process.exit(1);
+    }
+    if (!await rt.checkAvailable()) {
+      console.error(`\x1B[31mError: Runtime "${name}" is not available. Make sure the CLI is installed.\x1B[0m`);
+      process.exit(1);
+    }
+  }
+  const orchestrator = new OrchestratorImpl(config);
+  new ConsoleReporter().attach(orchestrator.eventBus);
+  const logDir = config.logDir ?? path3.join(config.workDir, "logs");
+  new FileLogWriter(logDir).attach(orchestrator.eventBus);
+  console.log(`\x1B[2mLogs: ${logDir}\x1B[0m`);
+  if (options.ui && options.serverUrl) {
+    console.warn("\x1B[33mWarning: --ui and --server-url cannot be used together. Using --ui.\x1B[0m");
+  }
+  if (options.ui) {
+    await attachDashboard(orchestrator, config, options);
+  } else if (options.serverUrl) {
+    await attachRemoteServer(orchestrator, options.serverUrl);
+  }
+  const result = await orchestrator.run();
+  process.exit(result.success ? 0 : 1);
+}
+async function attachDashboard(orchestrator, config, options) {
+  const { DashboardServer } = await import("@multiclawcli/dashboard/server");
+  const port = options.port ?? config.dashboard?.port ?? 3210;
+  const server = new DashboardServer({ port });
+  await server.start();
+  server.bindEventBus(orchestrator.eventBus);
+  const url = `http://localhost:${port}`;
+  console.log(`\x1B[36mDashboard: ${url}\x1B[0m`);
+  if (config.dashboard?.autoOpen ?? true) {
+    const { default: open } = await import("open");
+    await open(url);
+  }
+}
+async function attachRemoteServer(orchestrator, serverUrl) {
+  const { WebSocket } = await import("ws");
+  const wsUrl = serverUrl.replace(/^https?/, (p) => p === "https" ? "wss" : "ws");
+  const ws = new WebSocket(wsUrl);
+  await new Promise((resolve3, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Connection to serve timed out: ${serverUrl}`)), 5e3);
+    ws.on("open", () => {
+      clearTimeout(timer);
+      resolve3();
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+  console.log(`\x1B[36mConnected to Dashboard server: ${serverUrl}\x1B[0m`);
+  orchestrator.eventBus.subscribe((e) => {
+    if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(e));
+  });
+}
+
+// src/commands/init.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import { execSync } from "child_process";
+import { select, input } from "@inquirer/prompts";
+var AGENT_BLOCKS = {
+  simple: `    agents.architect(),
+    agents.archDesignReviewer({ dependsOn: ["architect"] }),
+    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
+    agents.codeReviewer({ dependsOn: ["backend-developer"] }),`,
+  backend: `    agents.productManager(),
+    agents.architect({ dependsOn: ["product-manager"] }),
+    agents.archDesignReviewer({ dependsOn: ["architect"] }),
+    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
+    agents.tester({ dependsOn: ["backend-developer"] }),
+    agents.codeReviewer({ dependsOn: ["tester"] }),
+    agents.devops({ dependsOn: ["tester"] }),`,
+  fullstack: `    agents.productManager(),
+    agents.architect({ dependsOn: ["product-manager"] }),
+    agents.archDesignReviewer({ dependsOn: ["architect"] }),
+    agents.backendDeveloper({ dependsOn: ["arch-design-reviewer"] }),
+    agents.uiDesigner({ dependsOn: ["arch-design-reviewer"] }),
+    agents.uiDesignReviewer({ dependsOn: ["ui-designer"] }),
+    agents.frontendDeveloper({ dependsOn: ["ui-design-reviewer"] }),
+    agents.codeReviewer({ dependsOn: ["backend-developer", "frontend-developer"] }),
+    agents.devops({ dependsOn: ["backend-developer", "frontend-developer"] }),`
+};
+var PRESET_DESCRIPTIONS = {
+  simple: "Architect \u2192 Arch Design Reviewer \u2192 Backend Developer \u2192 Code Reviewer  (4 agents)",
+  backend: "Product Manager \u2192 Architect \u2192 Arch Design Reviewer \u2192 Backend Developer \u2192 Tester \u2192 Code Reviewer + DevOps  (7 agents)",
+  fullstack: "Product Manager \u2192 Architect \u2192 Arch Design Reviewer \u2192 Backend Developer + UI Designer \u2192 UI Design Reviewer \u2192 Frontend Developer \u2192 Code Reviewer + DevOps  (9 agents)"
+};
+var RUNTIME_INSTALL = {
+  claude: "npm install -g @anthropic-ai/claude-code",
+  codex: "npm install -g @openai/codex",
+  opencode: "npm install -g opencode",
+  cursor: "curl https://cursor.com/install | bash"
+};
+function generateConfig(opts) {
+  return `import { defineConfig, agents } from "multiclaw"
+
+export default defineConfig({
+  name: "${opts.projectName}",
+  workDir: "${opts.workDir}",
+  context: {
+    projectName: "${opts.projectName}",
+  },
+  dashboard: { port: 3210, autoOpen: true },
+  agents: [
+${AGENT_BLOCKS[opts.preset]}
+  ],
+})
+`;
+}
+async function initCommand() {
+  const configPath = path4.resolve(process.cwd(), "multiclaw.config.ts");
+  if (fs3.existsSync(configPath)) {
+    console.error("\x1B[31mError: multiclaw.config.ts already exists\x1B[0m");
+    process.exit(1);
+  }
+  const defaultProjectName = path4.basename(process.cwd());
+  const projectName = await input({
+    message: "Project name:",
+    default: defaultProjectName
+  });
+  const preset = await select({
+    message: "Select a preset:",
+    choices: [
+      { value: "simple", name: `simple     \u2014 ${PRESET_DESCRIPTIONS.simple}` },
+      { value: "backend", name: `backend    \u2014 ${PRESET_DESCRIPTIONS.backend}` },
+      { value: "fullstack", name: `fullstack  \u2014 ${PRESET_DESCRIPTIONS.fullstack}` }
+    ]
+  });
+  const workDir = await input({
+    message: "Work directory (where agents read and write files):",
+    default: "."
+  });
+  try {
+    fs3.writeFileSync(configPath, generateConfig({ preset, workDir, projectName }));
+    if (workDir !== ".") {
+      fs3.mkdirSync(path4.resolve(process.cwd(), workDir), { recursive: true });
+    }
+  } catch (err) {
+    console.error(`\x1B[31mError: Failed to create files: ${err.message}\x1B[0m`);
+    process.exit(1);
+  }
+  console.log("");
+  console.log(`\x1B[32m\u2713\x1B[0m Created multiclaw.config.ts`);
+  console.log(`  preset:   ${preset}  (${PRESET_DESCRIPTIONS[preset]})`);
+  console.log(`  workDir:  ${workDir}`);
+  console.log("");
+  console.log(`> Run: multiclaw run "describe your requirement" --ui`);
+  checkRuntime();
+}
+function checkRuntime() {
+  const runtimes = ["claude", "codex", "opencode"];
+  const available = runtimes.filter((r) => {
+    try {
+      execSync(`${r} --version`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  if (available.length === 0) {
+    console.log("");
+    console.log("\x1B[33mWarning: No AI runtime detected. Install at least one:\x1B[0m");
+    for (const [name, cmd] of Object.entries(RUNTIME_INSTALL)) {
+      console.log(`  \x1B[2m${name.padEnd(12)} ${cmd}\x1B[0m`);
+    }
+  }
+}
+
+// src/commands/serve.ts
+async function serveCommand(options) {
+  const { DashboardServer } = await import("@multiclawcli/dashboard/server");
+  const port = options.port ?? 3210;
+  const server = new DashboardServer({ port, acceptClientEvents: true });
+  await server.start();
+  console.log(`\x1B[36mDashboard running at: http://localhost:${port}\x1B[0m`);
+  console.log(`  In another terminal run: multiclaw run "<requirement>" --server-url http://localhost:${port}`);
+}
+
+// src/commands/upgrade.ts
+import { execSync as execSync2 } from "child_process";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+async function upgradeCommand() {
+  const { version: currentVersion } = require2("../../package.json");
+  console.log(`Current version: v${currentVersion}`);
+  console.log("Checking for updates...");
+  let latestVersion;
+  try {
+    latestVersion = execSync2("npm show multiclaw version", { encoding: "utf8" }).trim();
+  } catch {
+    console.error("\x1B[31mError: Failed to fetch latest version from npm registry\x1B[0m");
     process.exit(1);
+    return;
+  }
+  if (latestVersion === currentVersion) {
+    console.log(`\x1B[32m\u2713\x1B[0m Already on the latest version (v${currentVersion})`);
+    return;
+  }
+  console.log(`Upgrading multiclaw v${currentVersion} \u2192 v${latestVersion}...`);
+  try {
+    execSync2("npm install -g multiclaw@latest", { stdio: "inherit" });
+    console.log(`\x1B[32m\u2713\x1B[0m Successfully upgraded to v${latestVersion}`);
+  } catch {
+    console.error("\x1B[31mError: Upgrade failed. Try running manually: npm install -g multiclaw@latest\x1B[0m");
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var pkg = JSON.parse(readFileSync(join3(__dirname2, "../package.json"), "utf-8"));
+var program = new Command();
+program.name("multiclaw").description("Multi-agent orchestration CLI").version(pkg.version, "-v, --version", "Display version number");
+program.command("init").description("Scaffold a config file (interactive)").action(() => initCommand());
+program.command("run <requirement>").description("Run an orchestration").option("--config <path>", "Config file path (default: auto-discover ./multiclaw.config.ts)").option("--ui", "Start Dashboard and open in browser").option("--port <port>", "Dashboard port (requires --ui)", (v) => parseInt(v, 10)).option("--server-url <url>", "Connect to a running serve process").option("--no-leader", "Skip the leader agent and use the default pipeline").action((requirement, opts) => runCommand(requirement, opts));
+program.command("serve").description("Start a persistent Dashboard server").option("--port <port>", "Port", (v) => parseInt(v, 10)).action((opts) => serveCommand(opts));
+program.command("upgrade").description("Upgrade multiclaw to the latest version").action(() => upgradeCommand());
+program.parseAsync(process.argv).catch((err) => {
+  console.error(`\x1B[31mError: ${err.message ?? err}\x1B[0m`);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map

package/dist/lib.js

@@ -1,2 +1,6 @@
-export { defineConfig, agents } from "@multiclawcli/core";
-//# sourceMappingURL=lib.js.map
+// src/lib.ts
+import { defineConfig, agents } from "@multiclawcli/core";
+export {
+  agents,
+  defineConfig
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiclaw",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "bin": {
     "multiclaw": "dist/index.js"
@@ -24,8 +24,8 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.7.3",
-    "@multiclawcli/core": "0.2.0",
-    "@multiclawcli/dashboard": "0.2.0",
+    "@multiclawcli/core": "0.3.1",
+    "@multiclawcli/dashboard": "0.3.1",
     "commander": "^12.0.0",
     "open": "^10.0.0",
     "tsx": "^4.7.0",
@@ -37,7 +37,7 @@
     "typescript": "^5.4.0"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
     "dev": "tsx src/index.ts"
   }
 }

package/src/index.ts

@@ -1,16 +1,23 @@
 #!/usr/bin/env node
 import { Command } from "commander"
+import { readFileSync } from "fs"
+import { dirname, join } from "path"
+import { fileURLToPath } from "url"
 import { runCommand } from "./commands/run"
 import { initCommand } from "./commands/init"
 import { serveCommand } from "./commands/serve"
 import { upgradeCommand } from "./commands/upgrade"
 
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"))
+
 const program = new Command()
 
 program
   .name("multiclaw")
   .description("Multi-agent orchestration CLI")
-  .version("0.1.0")
+  .version(pkg.version, "-v, --version", "Display version number")
 
 program
   .command("init")

package/tsup.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig([
+  {
+    entry: { index: "src/index.ts" },
+    format: ["esm"],
+    outDir: "dist",
+    clean: true,
+    shims: true,
+  },
+  {
+    entry: { lib: "src/lib.ts" },
+    format: ["esm"],
+    outDir: "dist",
+    dts: true,
+    shims: true,
+  },
+])