multiclaw 0.3.1 → 0.3.2

package/dist/index.js

@@ -381,7 +381,7 @@ 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");
+  const { version: currentVersion } = require2("../package.json");
   console.log(`Current version: v${currentVersion}`);
   console.log("Checking for updates...");
   let latestVersion;

package/dist/lib.d.ts

@@ -0,0 +1 @@
+export { AgentDefinition, MultiClawConfig, agents, defineConfig } from '@multiclawcli/core';

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "multiclaw",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "bin": {
     "multiclaw": "dist/index.js"
   },
+  "files": [
+    "dist",
+    "package.json"
+  ],
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
   "exports": {
@@ -24,8 +28,8 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.7.3",
-    "@multiclawcli/core": "0.3.1",
-    "@multiclawcli/dashboard": "0.3.1",
+    "@multiclawcli/core": "0.3.2",
+    "@multiclawcli/dashboard": "0.3.2",
     "commander": "^12.0.0",
     "open": "^10.0.0",
     "tsx": "^4.7.0",

package/src/commands/init.ts

@@ -1,128 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import { execSync } from "child_process"
-import { select, input } from "@inquirer/prompts"
-
-// ─── Agent Block Definitions ──────────────────────────────────────────────────
-
-const AGENT_BLOCKS: Record<string, string> = {
-  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"] }),`,
-}
-
-const PRESET_DESCRIPTIONS: Record<string, string> = {
-  simple:    "Architect → Arch Design Reviewer → Backend Developer → Code Reviewer  (4 agents)",
-  backend:   "Product Manager → Architect → Arch Design Reviewer → Backend Developer → Tester → Code Reviewer + DevOps  (7 agents)",
-  fullstack: "Product Manager → Architect → Arch Design Reviewer → Backend Developer + UI Designer → UI Design Reviewer → Frontend Developer → Code Reviewer + DevOps  (9 agents)",
-}
-
-const RUNTIME_INSTALL: Record<string, string> = {
-  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",
-}
-
-// ─── Config Generator ─────────────────────────────────────────────────────────
-
-function generateConfig(opts: { preset: string; workDir: string; projectName: string }): string {
-  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]}
-  ],
-})
-`
-}
-
-// ─── Command ──────────────────────────────────────────────────────────────────
-
-export async function initCommand(): Promise<void> {
-  const configPath = path.resolve(process.cwd(), "multiclaw.config.ts")
-  if (fs.existsSync(configPath)) {
-    console.error("\x1b[31mError: multiclaw.config.ts already exists\x1b[0m")
-    process.exit(1)
-  }
-
-  const defaultProjectName = path.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     — ${PRESET_DESCRIPTIONS.simple}` },
-      { value: "backend",   name: `backend    — ${PRESET_DESCRIPTIONS.backend}` },
-      { value: "fullstack", name: `fullstack  — ${PRESET_DESCRIPTIONS.fullstack}` },
-    ],
-  })
-
-  const workDir = await input({
-    message: "Work directory (where agents read and write files):",
-    default: ".",
-  })
-
-  try {
-    fs.writeFileSync(configPath, generateConfig({ preset, workDir, projectName }))
-    if (workDir !== ".") {
-      fs.mkdirSync(path.resolve(process.cwd(), workDir), { recursive: true })
-    }
-  } catch (err) {
-    console.error(`\x1b[31mError: Failed to create files: ${(err as Error).message}\x1b[0m`)
-    process.exit(1)
-  }
-
-  console.log("")
-  console.log(`\x1b[32m✓\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(): void {
-  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`)
-    }
-  }
-}

package/src/commands/run.ts

@@ -1,97 +0,0 @@
-import * as path from "path"
-import type { Orchestrator } from "@multiclawcli/core"
-import { Orchestrator as OrchestratorImpl, runtimeRegistry } from "@multiclawcli/core"
-import { loadConfig } from "../loader/loadConfig"
-import { ConsoleReporter } from "../reporters/ConsoleReporter"
-import { FileLogWriter } from "../reporters/FileLogWriter"
-
-export interface RunOptions {
-  config?: string
-  ui?: boolean
-  serverUrl?: string
-  port?: number
-  noLeader?: boolean
-}
-
-export async function runCommand(requirement: string, options: RunOptions): Promise<void> {
-  const config = await loadConfig(options.config, requirement)
-
-  if (options.noLeader) {
-    config.useLeader = false
-  }
-
-  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)
-  config.workDir = path.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 ?? path.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: Orchestrator,
-  config: Awaited<ReturnType<typeof loadConfig>>,
-  options: RunOptions
-): Promise<void> {
-  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: Orchestrator,
-  serverUrl: string
-): Promise<void> {
-  const { WebSocket } = await import("ws")
-  const wsUrl = serverUrl.replace(/^https?/, (p) => p === "https" ? "wss" : "ws")
-  const ws = new WebSocket(wsUrl)
-  await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`Connection to serve timed out: ${serverUrl}`)), 5000)
-    ws.on("open", () => { clearTimeout(timer); resolve() })
-    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))
-  })
-}

package/src/commands/serve.ts

@@ -1,12 +0,0 @@
-export interface ServeOptions {
-  port?: number
-}
-
-export async function serveCommand(options: ServeOptions): Promise<void> {
-  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}`)
-}

package/src/commands/upgrade.ts

@@ -1,35 +0,0 @@
-import { execSync } from "child_process"
-import { createRequire } from "module"
-
-const require = createRequire(import.meta.url)
-
-export async function upgradeCommand(): Promise<void> {
-  const { version: currentVersion } = require("../../package.json") as { version: string }
-
-  console.log(`Current version: v${currentVersion}`)
-  console.log("Checking for updates...")
-
-  let latestVersion: string
-  try {
-    latestVersion = execSync("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✓\x1b[0m Already on the latest version (v${currentVersion})`)
-    return
-  }
-
-  console.log(`Upgrading multiclaw v${currentVersion} → v${latestVersion}...`)
-
-  try {
-    execSync("npm install -g multiclaw@latest", { stdio: "inherit" })
-    console.log(`\x1b[32m✓\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)
-  }
-}

package/src/index.ts

@@ -1,51 +0,0 @@
-#!/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(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: unknown) => {
-  console.error(`\x1b[31mError: ${(err as Error).message ?? err}\x1b[0m`)
-  process.exit(1)
-})

package/src/lib.ts

@@ -1,2 +0,0 @@
-export { defineConfig, agents } from "@multiclawcli/core"
-export type { MultiClawConfig, AgentDefinition } from "@multiclawcli/core"

package/src/loader/loadConfig.ts

@@ -1,47 +0,0 @@
-import * as path from "path"
-import * as fs from "fs"
-import type { MultiClawConfig } from "@multiclawcli/core"
-
-const DEFAULT_CONFIG_NAMES = ["multiclaw.config.ts", "multiclaw.config.js"]
-
-function findConfig(configPath?: string): string {
-  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.`)
-}
-
-export async function loadConfig(configPath?: string, requirement?: string): Promise<MultiClawConfig> {
-  const absPath = findConfig(configPath)
-
-  // The compiled CLI cannot natively import .ts files — register tsx ESM hook
-  // so dynamic import can handle TypeScript config files.
-  const { register } = await import("tsx/esm/api")
-  const unregister = register()
-  let mod: Record<string, unknown>
-  try {
-    mod = await import(absPath)
-  } finally {
-    unregister()
-  }
-  const config: MultiClawConfig = (mod.default ?? mod.config) as MultiClawConfig
-
-  if (!config || !Array.isArray(config.agents)) {
-    throw new Error(`Invalid config format — expected: export default defineConfig({...})`)
-  }
-
-  const configDir = path.dirname(absPath)
-  config.workDir = path.resolve(configDir, config.workDir)
-
-  if (requirement !== undefined) {
-    config.context = { ...config.context, requirement }
-  }
-
-  return config
-}

package/src/reporters/ConsoleReporter.ts

@@ -1,93 +0,0 @@
-import type { EventBus, MultiClawEvent } from "@multiclawcli/core"
-
-// Degraded to plain ASCII when NO_COLOR is set, TERM=dumb, or stdout is not a TTY (pipe/CI).
-const isFancy =
-  !process.env.NO_COLOR &&
-  process.env.TERM !== "dumb" &&
-  process.stdout.isTTY === true
-
-const S = isFancy
-  ? { ok: "✓", fail: "✗", run: "›", retry: "↻", skip: "⊘", warn: "⚠", bullet: "·" }
-  : { ok: "+", fail: "x", run: ">", retry: "~", skip: "-", warn: "!", bullet: "*" }
-
-const 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: "",
-    }
-
-export class ConsoleReporter {
-  attach(eventBus: EventBus): () => void {
-    return eventBus.subscribe((e) => this.handle(e))
-  }
-
-  private handle(e: MultiClawEvent): void {
-    switch (e.type) {
-      case "orchestration:start": {
-        const line = (isFancy ? "═" : "=").repeat(50)
-        const edge = isFancy ? ["╔", "║", "╚", "╗", "╝"] : ["+", "|", "+", "+", "+"]
-        console.log(`\n${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}\n`)
-        break
-      }
-      case "stage:start": {
-        const dash = (isFancy ? "─" : "-").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 / 1000).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 ? "═" : "=").repeat(50)
-        const edge = isFancy ? ["╔", "║", "╚", "╗", "╝"] : ["+", "|", "+", "+", "+"]
-        const title = success ? `${S.ok} All done` : `${S.warn} Done (with failures)`
-        console.log(`\n${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 / 1000).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 / 1000).toFixed(1)}s`
-          console.log(`  ${color}${icon}${C.reset} ${r.agentName.padEnd(nameWidth)}   ${dur.padStart(7)}`)
-        }
-        console.log()
-        break
-      }
-    }
-  }
-}

package/src/reporters/FileLogWriter.ts

@@ -1,43 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import type { EventBus, MultiClawEvent } from "@multiclawcli/core"
-
-export class FileLogWriter {
-  private streams = new Map<string, fs.WriteStream>()
-
-  constructor(private logDir: string) {
-    fs.mkdirSync(logDir, { recursive: true })
-  }
-
-  attach(eventBus: EventBus): () => void {
-    return eventBus.subscribe((e) => this.handle(e))
-  }
-
-  private handle(e: MultiClawEvent): void {
-    if (e.type === "agent:output") {
-      this.getStream(e.payload.agentId).write(e.payload.chunk)
-    }
-    if (e.type === "orchestration:complete") {
-      fs.writeFileSync(
-        path.join(this.logDir, "report.json"),
-        JSON.stringify(e.payload, null, 2)
-      )
-      this.closeAll()
-    }
-  }
-
-  private getStream(agentId: string): fs.WriteStream {
-    if (!this.streams.has(agentId)) {
-      this.streams.set(
-        agentId,
-        fs.createWriteStream(path.join(this.logDir, `${agentId}.log`))
-      )
-    }
-    return this.streams.get(agentId)!
-  }
-
-  private closeAll(): void {
-    for (const s of this.streams.values()) s.end()
-    this.streams.clear()
-  }
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
-  "references": [
-    { "path": "../core" },
-    { "path": "../dashboard/tsconfig.server.json" }
-  ],
-  "include": ["src"]
-}

package/tsup.config.ts

@@ -1,18 +0,0 @@
-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,
-  },
-])