@oxgeneral/orch 0.3.3 → 0.3.4

package/dist/agent-KBTLGGCT.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import { agentToEditorContent, openInEditor, agentFromEditorContent } from './chunk-P6ATSXGL.js';
+import { printSuccess, agentName, printTable, dim, statusIcon, formatTokens, printKeyValue } from './chunk-7X2GI5OV.js';
+
+// src/cli/commands/agent.ts
+function registerAgentCommand(program, container) {
+  const agent = program.command("agent").description("Manage agents");
+  agent.command("add <name>").description("Add a new agent").requiredOption("--adapter <adapter>", "Adapter type: claude, shell, codex, cursor").option("--role <role>", "Agent role description").option("--command <cmd>", "Shell command (for shell adapter)").option("--model <model>", "Model name (for AI adapters)").option("--max-turns <n>", "Max turns per run").option("--timeout <ms>", "Timeout in ms").option("--approval-policy <policy>", "suggest|auto|manual").option("--workspace-mode <mode>", "shared|worktree|isolated").option("--skills <skills>", "Comma-separated list of agent skills").option("-e, --edit", "Open $EDITOR to write the role description").action(async (name, opts) => {
+    await container.paths.requireInit();
+    let role = opts.role;
+    if (opts.edit) {
+      const initial = agentToEditorContent({ name, model: opts.model, role });
+      const edited = await openInEditor(initial);
+      const parsed = agentFromEditorContent(edited);
+      if (parsed.name) name = parsed.name;
+      if (parsed.model) opts.model = parsed.model;
+      if (parsed.role) role = parsed.role;
+    }
+    const a = await container.agentService.create({
+      name,
+      adapter: opts.adapter,
+      role,
+      command: opts.command,
+      model: opts.model,
+      max_turns: opts.maxTurns ? parseInt(opts.maxTurns, 10) : void 0,
+      timeout_ms: opts.timeout ? parseInt(opts.timeout, 10) : void 0,
+      approval_policy: opts.approvalPolicy,
+      workspace_mode: opts.workspaceMode,
+      skills: opts.skills ? opts.skills.split(",").map((s) => s.trim()) : void 0
+    });
+    if (container.context.json) {
+      console.log(JSON.stringify(a, null, 2));
+    } else if (container.context.quiet) {
+      console.log(a.id);
+    } else {
+      printSuccess(`Added agent ${agentName(a.name)} (${a.adapter}) \u2192 ${a.id}`);
+    }
+  });
+  agent.command("shop").description("Browse and install pre-built agent templates").option("--list", "Print all templates (non-interactive)").action(async (opts) => {
+    await container.paths.requireInit();
+    const { AGENT_SHOP_TEMPLATES } = await import('./agent-shop-YN2BSLHM.js');
+    if (opts.list || !process.stdout.isTTY) {
+      printTable(
+        ["Key", "Name", "Adapter", "Model", "Skills"],
+        AGENT_SHOP_TEMPLATES.map((t) => [t.key, t.name, t.adapter, t.model.replace("claude-", ""), t.skills.slice(0, 2).join(", ")])
+      );
+      return;
+    }
+    const { pickFromShop } = await import('./shop-picker-2HY67UWP.js');
+    const template = await pickFromShop(AGENT_SHOP_TEMPLATES);
+    if (!template) {
+      console.log("  Cancelled.");
+      return;
+    }
+    const a = await container.agentService.create({
+      name: template.name,
+      adapter: template.adapter,
+      model: template.model,
+      role: template.role,
+      skills: template.skills,
+      approval_policy: template.approval_policy
+    });
+    printSuccess(`Added agent ${agentName(a.name)} (${a.adapter}) \u2192 ${a.id}`);
+  });
+  agent.command("list").description("List all agents").action(async () => {
+    await container.paths.requireInit();
+    const agents = await container.agentService.list();
+    if (container.context.json) {
+      console.log(JSON.stringify(agents, null, 2));
+      return;
+    }
+    if (container.context.quiet) {
+      agents.forEach((a) => console.log(a.id));
+      return;
+    }
+    if (agents.length === 0) {
+      console.log(`
+  No agents. Add one: ${dim("orch agent add <name> --adapter claude")}
+`);
+      return;
+    }
+    const headers = ["STATUS", "AGENT", "ADAPTER", "TASK", "TIME"];
+    const rows = agents.map((a) => [
+      `${statusIcon(a.status)} ${a.status}`,
+      agentName(a.name),
+      a.adapter,
+      a.current_task ?? dim("\u2014"),
+      dim("\u2014")
+    ]);
+    console.log();
+    printTable(headers, rows);
+    const running = agents.filter((a) => a.status === "running").length;
+    console.log(
+      `
+  ${agents.length} agents \xB7 ${running} running \xB7 ${formatTokens(agents.reduce((sum, a) => sum + (a.stats.tokens_used ?? 0), 0))} tokens total
+`
+    );
+  });
+  agent.command("status <id>").description("Show agent details").action(async (id) => {
+    await container.paths.requireInit();
+    const a = await container.agentService.get(id);
+    if (container.context.json) {
+      console.log(JSON.stringify(a, null, 2));
+      return;
+    }
+    console.log(`
+  ${a.name}`);
+    console.log(`  ${"\u2550".repeat(42)}`);
+    console.log();
+    const pairs = [
+      ["Adapter", `${a.adapter}${a.config.model ? ` (${a.config.model})` : ""}`],
+      ["Status", `${statusIcon(a.status)} ${a.status}`],
+      ["Policy", a.config.approval_policy ?? "auto"]
+    ];
+    if (a.current_task) pairs.push(["Task", a.current_task]);
+    if (a.role) pairs.push(["Role", a.role]);
+    if (a.config.skills?.length) pairs.push(["Skills", a.config.skills.join(", ")]);
+    printKeyValue(pairs);
+    console.log(`
+  Stats
+  ${"\u2500".repeat(42)}`);
+    printKeyValue([
+      ["Tasks completed", String(a.stats.tasks_completed)],
+      ["Tasks failed", String(a.stats.tasks_failed)],
+      ["Total runs", String(a.stats.total_runs)],
+      ["Tokens used", formatTokens(a.stats.tokens_used ?? 0)]
+    ]);
+    console.log();
+  });
+  agent.command("edit <id>").description("Edit an agent in $EDITOR").action(async (id) => {
+    await container.paths.requireInit();
+    const a = await container.agentService.get(id);
+    const initial = agentToEditorContent({
+      name: a.name,
+      model: a.config.model,
+      role: a.role
+    });
+    const edited = await openInEditor(initial);
+    const parsed = agentFromEditorContent(edited);
+    const updated = await container.agentService.update(id, {
+      name: parsed.name,
+      role: parsed.role,
+      model: parsed.model
+    });
+    if (container.context.json) {
+      console.log(JSON.stringify(updated, null, 2));
+    } else if (container.context.quiet) {
+      console.log(updated.id);
+    } else {
+      printSuccess(`Updated agent ${agentName(updated.name)} (${updated.id})`);
+    }
+  });
+  agent.command("remove <id>").description("Remove an agent").action(async (id) => {
+    await container.paths.requireInit();
+    await container.agentService.remove(id);
+    printSuccess(`Removed agent ${id}`);
+  });
+  agent.command("disable <id>").description("Disable an agent").action(async (id) => {
+    await container.paths.requireInit();
+    await container.agentService.disable(id);
+    printSuccess(`Disabled agent ${id}`);
+  });
+  agent.command("enable <id>").description("Enable an agent").action(async (id) => {
+    await container.paths.requireInit();
+    await container.agentService.enable(id);
+    printSuccess(`Enabled agent ${id}`);
+  });
+  agent.command("autonomous <id>").description("Toggle autonomous mode for an agent").option("--on", "Enable autonomous mode").option("--off", "Disable autonomous mode").action(async (id, opts) => {
+    await container.paths.requireInit();
+    const current = await container.agentService.get(id);
+    const enable = opts.on ? true : opts.off ? false : !current.autonomous;
+    const a = await container.agentService.setAutonomous(id, enable);
+    if (container.context.json) {
+      console.log(JSON.stringify(a, null, 2));
+    } else if (container.context.quiet) {
+      console.log(a.id);
+    } else {
+      printSuccess(`Autonomous mode ${enable ? "enabled" : "disabled"} for agent ${agentName(a.name)} (${a.id})`);
+    }
+  });
+}
+
+export { registerAgentCommand };

package/dist/agent-shop-YN2BSLHM.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { AGENT_SHOP_TEMPLATES, getShopTemplateByKey } from './chunk-DAVHOWGD.js';

package/dist/chunk-2C2TFQ7K.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+// src/domain/errors.ts
+var OrchestryError = class extends Error {
+  constructor(message, exitCode, hint) {
+    super(message);
+    this.exitCode = exitCode;
+    this.hint = hint;
+    this.name = "OrchestryError";
+  }
+};
+var NotInitializedError = class extends OrchestryError {
+  constructor() {
+    super("Not initialized", 3, "Run: orch init");
+    this.name = "NotInitializedError";
+  }
+};
+var InvalidArgumentsError = class extends OrchestryError {
+  constructor(message) {
+    super(message, 2);
+    this.name = "InvalidArgumentsError";
+  }
+};
+var LockConflictError = class extends OrchestryError {
+  constructor(pid) {
+    super(`Orchestrator already running (PID: ${pid})`, 4, "Use: orch status");
+    this.name = "LockConflictError";
+  }
+};
+var NoAgentsError = class extends OrchestryError {
+  constructor() {
+    super("No agents configured", 1, "Run: orch agent add <name> --adapter claude");
+    this.name = "NoAgentsError";
+  }
+};
+var TaskNotFoundError = class extends OrchestryError {
+  constructor(taskId) {
+    super(`Task not found: ${taskId}`, 1);
+    this.name = "TaskNotFoundError";
+  }
+};
+var AgentNotFoundError = class extends OrchestryError {
+  constructor(agentId) {
+    super(`Agent not found: ${agentId}`, 1);
+    this.name = "AgentNotFoundError";
+  }
+};
+var TaskAlreadyRunningError = class extends OrchestryError {
+  constructor(taskId, runId, agentName) {
+    super(
+      `Task ${taskId} is already running (run: ${runId}, agent: ${agentName})`,
+      1,
+      `Use: orch logs --task ${taskId} --follow`
+    );
+    this.name = "TaskAlreadyRunningError";
+  }
+};
+var InvalidTransitionError = class extends OrchestryError {
+  constructor(taskId, from, to) {
+    super(`Invalid transition for ${taskId}: ${from} \u2192 ${to}`, 1);
+    this.name = "InvalidTransitionError";
+  }
+};
+var GoalNotFoundError = class extends OrchestryError {
+  constructor(goalId) {
+    super(`Goal not found: ${goalId}`, 1);
+    this.name = "GoalNotFoundError";
+  }
+};
+var TeamNotFoundError = class extends OrchestryError {
+  constructor(teamId) {
+    super(`Team not found: ${teamId}`, 1);
+    this.name = "TeamNotFoundError";
+  }
+};
+var WorkspaceError = class extends OrchestryError {
+  constructor(message, hint) {
+    super(message, 6, hint);
+    this.name = "WorkspaceError";
+  }
+};
+var ERROR_HINTS = {
+  ["adapter_not_found" /* ADAPTER_NOT_FOUND */]: {
+    message: "CLI \u043D\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D.",
+    fix: "\u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435: npm i -g @anthropic-ai/claude-code",
+    doctorHint: true
+  },
+  ["auth_failed" /* AUTH_FAILED */]: {
+    message: "API \u043A\u043B\u044E\u0447 \u043D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D.",
+    fix: "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435: claude auth status"
+  },
+  ["timeout" /* TIMEOUT */]: {
+    message: "\u0410\u0433\u0435\u043D\u0442 \u043F\u0440\u0435\u0432\u044B\u0441\u0438\u043B \u043B\u0438\u043C\u0438\u0442 \u0432\u0440\u0435\u043C\u0435\u043D\u0438.",
+    fix: "\u0423\u0432\u0435\u043B\u0438\u0447\u044C\u0442\u0435 \u0447\u0435\u0440\u0435\u0437: orch config set agent_timeout <ms>"
+  },
+  ["rate_limit" /* RATE_LIMIT */]: {
+    message: "\u0414\u043E\u0441\u0442\u0438\u0433\u043D\u0443\u0442 \u043B\u0438\u043C\u0438\u0442 API.",
+    fix: "\u041F\u043E\u0434\u043E\u0436\u0434\u0438\u0442\u0435 \u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0435: orch task retry <id>"
+  },
+  ["process_crash" /* PROCESS_CRASH */]: {
+    message: "\u041F\u0440\u043E\u0446\u0435\u0441\u0441 \u0430\u0433\u0435\u043D\u0442\u0430 \u0443\u043F\u0430\u043B.",
+    fix: "\u041F\u043E\u043F\u0440\u043E\u0431\u0443\u0439\u0442\u0435: orch task retry <id>"
+  },
+  ["spawn_failed" /* SPAWN_FAILED */]: {
+    message: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C \u043F\u0440\u043E\u0446\u0435\u0441\u0441.",
+    fix: "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 PATH \u0438 \u043F\u0440\u0430\u0432\u0430 \u0434\u043E\u0441\u0442\u0443\u043F\u0430"
+  },
+  ["unknown" /* UNKNOWN */]: {
+    message: "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430.",
+    fix: "\u0417\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435: orch doctor",
+    doctorHint: true
+  }
+};
+function classifyAdapterError(error, exitCode) {
+  const lower = error.toLowerCase();
+  if (lower.includes("enoent") || lower.includes("spawn failed")) {
+    return "spawn_failed" /* SPAWN_FAILED */;
+  }
+  if (lower.includes("not found") || lower.includes("command not found") || lower.includes("no such file")) {
+    return "adapter_not_found" /* ADAPTER_NOT_FOUND */;
+  }
+  if (lower.includes("auth") || lower.includes("unauthorized") || lower.includes("401") || lower.includes("invalid api key") || lower.includes("authentication")) {
+    return "auth_failed" /* AUTH_FAILED */;
+  }
+  if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("etimedout")) {
+    return "timeout" /* TIMEOUT */;
+  }
+  if (lower.includes("rate limit") || lower.includes("429") || lower.includes("too many requests")) {
+    return "rate_limit" /* RATE_LIMIT */;
+  }
+  if (exitCode !== void 0 && exitCode !== 0) {
+    return "process_crash" /* PROCESS_CRASH */;
+  }
+  return "unknown" /* UNKNOWN */;
+}
+
+export { AgentNotFoundError, ERROR_HINTS, GoalNotFoundError, InvalidArgumentsError, InvalidTransitionError, LockConflictError, NoAgentsError, NotInitializedError, OrchestryError, TaskAlreadyRunningError, TaskNotFoundError, TeamNotFoundError, WorkspaceError, classifyAdapterError };

package/dist/chunk-45K2XID7.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// src/infrastructure/adapters/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.adapters.set(adapter.kind, adapter);
+  }
+  get(kind) {
+    return this.adapters.get(kind);
+  }
+  require(kind) {
+    const adapter = this.adapters.get(kind);
+    if (!adapter) {
+      throw new Error(`Unknown adapter: "${kind}". Available: ${this.listKinds().join(", ")}`);
+    }
+    return adapter;
+  }
+  list() {
+    return Array.from(this.adapters.values());
+  }
+  listKinds() {
+    return Array.from(this.adapters.keys());
+  }
+  has(kind) {
+    return this.adapters.has(kind);
+  }
+};
+
+export { AdapterRegistry };

package/dist/chunk-52BFUGDD.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import { readLines } from './chunk-CHIP7O6V.js';
+import { classifyAdapterError } from './chunk-2C2TFQ7K.js';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+// src/infrastructure/adapters/event-buffer.ts
+var DEFAULT_CAPACITY = 1024;
+function deferred() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+var EventBuffer = class {
+  buf;
+  head = 0;
+  // read index
+  tail = 0;
+  // write index
+  count = 0;
+  capacity;
+  // Consumer notification: resolved when new data is available
+  dataReady = null;
+  // Producer notification: resolved when space is available
+  spaceReady = null;
+  closed = false;
+  constructor(capacity = DEFAULT_CAPACITY) {
+    this.capacity = capacity;
+    this.buf = new Array(capacity);
+  }
+  /** Number of buffered events. */
+  get size() {
+    return this.count;
+  }
+  get isFull() {
+    return this.count >= this.capacity;
+  }
+  /**
+   * Push an event into the buffer.
+   * If the buffer is full, waits until space is available (backpressure).
+   */
+  async push(event) {
+    while (this.isFull && !this.closed) {
+      if (!this.spaceReady) {
+        this.spaceReady = deferred();
+      }
+      await this.spaceReady.promise;
+    }
+    if (this.closed) return;
+    this.buf[this.tail] = event;
+    this.tail = (this.tail + 1) % this.capacity;
+    this.count++;
+    if (this.dataReady) {
+      const dr = this.dataReady;
+      this.dataReady = null;
+      dr.resolve();
+    }
+  }
+  /**
+   * Dequeue the next event. O(1).
+   * Returns undefined only when buffer is empty AND closed.
+   */
+  async take() {
+    while (this.count === 0) {
+      if (this.closed) return void 0;
+      if (!this.dataReady) {
+        this.dataReady = deferred();
+      }
+      await this.dataReady.promise;
+    }
+    const event = this.buf[this.head];
+    this.buf[this.head] = void 0;
+    this.head = (this.head + 1) % this.capacity;
+    this.count--;
+    if (this.spaceReady) {
+      const sr = this.spaceReady;
+      this.spaceReady = null;
+      sr.resolve();
+    }
+    return event;
+  }
+  /**
+   * Signal that no more events will be pushed.
+   * Wakes up any waiting consumer/producer.
+   */
+  close() {
+    this.closed = true;
+    if (this.dataReady) {
+      const dr = this.dataReady;
+      this.dataReady = null;
+      dr.resolve();
+    }
+    if (this.spaceReady) {
+      const sr = this.spaceReady;
+      this.spaceReady = null;
+      sr.resolve();
+    }
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  /**
+   * Async iterator that drains the buffer until closed and empty.
+   */
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const event = await this.take();
+      if (event === void 0) return;
+      yield event;
+    }
+  }
+};
+var execFileAsync = promisify(execFile);
+var ShellAdapter = class {
+  constructor(processManager) {
+    this.processManager = processManager;
+  }
+  kind = "shell";
+  async test() {
+    try {
+      const { stdout } = await execFileAsync("bash", ["--version"]);
+      const version = stdout.split("\n")[0]?.trim() ?? "unknown";
+      return { ok: true, version };
+    } catch {
+      return { ok: false, error: "bash not found", errorKind: classifyAdapterError("bash not found") };
+    }
+  }
+  execute(params) {
+    const command = params.config.command;
+    if (!command) {
+      async function* errorGen() {
+        yield {
+          type: "error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: "Shell adapter requires a command in agent config",
+          errorKind: "spawn_failed" /* SPAWN_FAILED */
+        };
+      }
+      return { pid: 0, events: errorGen() };
+    }
+    const { process: proc, pid } = this.processManager.spawn("bash", ["-lc", command], {
+      cwd: params.workspace,
+      env: {
+        ...process.env,
+        ...params.env,
+        ORCHESTRY_TASK_PROMPT: params.prompt
+      },
+      signal: params.signal
+    });
+    const signal = params.signal;
+    const processManager = this.processManager;
+    async function* generateEvents() {
+      const buffer = new EventBuffer();
+      const onAbort = () => {
+        processManager.killWithGrace(pid, 5e3).catch(() => {
+        });
+      };
+      if (signal) {
+        if (signal.aborted) {
+          onAbort();
+        } else {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+      }
+      const stdoutPromise = (async () => {
+        if (!proc.stdout) return;
+        for await (const line of readLines(proc.stdout)) {
+          if (signal?.aborted) break;
+          await buffer.push({
+            type: "output",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: line
+          });
+        }
+      })();
+      const stderrPromise = (async () => {
+        if (!proc.stderr) return;
+        for await (const line of readLines(proc.stderr)) {
+          if (signal?.aborted) break;
+          await buffer.push({
+            type: "error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: line,
+            errorKind: classifyAdapterError(line)
+          });
+        }
+      })();
+      void Promise.all([stdoutPromise, stderrPromise]).then(
+        () => buffer.close(),
+        () => buffer.close()
+      );
+      yield* buffer;
+      if (signal && !signal.aborted) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      await new Promise((resolve, reject) => {
+        if (proc.exitCode !== null || proc.killed) {
+          resolve();
+          return;
+        }
+        proc.on("close", (code) => {
+          if (code === 0 || signal?.aborted) {
+            resolve();
+          } else {
+            reject(new Error(`Shell command exited with code ${code}`));
+          }
+        });
+        proc.on("error", reject);
+      });
+    }
+    return { pid, events: generateEvents() };
+  }
+  async stop(pid) {
+    await this.processManager.killWithGrace(pid);
+  }
+};
+
+export { ShellAdapter };