@oxgeneral/orch 0.3.3 → 0.3.4

package/dist/init-U7MCIOB2.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { DEFAULT_PROMPT_TEMPLATE } from './chunk-A36WAF2S.js';
+import { DEFAULT_CONFIG } from './chunk-I3SMISEF.js';
+import './chunk-PNE6LQRF.js';
+import { printWarning, printSuccess, dim } from './chunk-7X2GI5OV.js';
+import { Paths, pathExists, ensureDir, writeYaml, atomicWrite } from './chunk-LV6GDBBI.js';
+import './chunk-2C2TFQ7K.js';
+import path from 'path';
+import fs from 'fs/promises';
+
+// src/domain/default-agents.ts
+var AGENT_CREATOR_ROLE = `Agent architect \u2014 designs and creates AI agents for the orchestrator via \`orch agent add\`.
+
+## CREATION PROCESS
+
+1) ANALYZE \u2014 determine: agent function, required skills, adapter, team interactions.
+
+2) WRITE THE ROLE \u2014 this is the most important part. A good role includes:
+   - Identity and specialization (who you are)
+   - Concrete workflow (numbered steps)
+   - Which skills to invoke (\`/skill-name\`)
+   - Rules and constraints
+   Do NOT include CLI documentation or goal-mode instructions \u2014 these are already injected by the system prompt template.
+
+3) CHOOSE CONFIGURATION:
+   - adapter: \`claude\` (AI tasks), \`shell\` (bash scripts), \`codex\` (OpenAI Codex), \`cursor\` (Cursor IDE)
+   - model: \`claude-opus-4-6\` (complex/architectural), \`claude-sonnet-4-6\` (fast/routine), \`claude-haiku-4-5-20251001\` (simple/templated)
+   - approval_policy: \`auto\` (no confirmation) / \`suggest\` (proposes actions) / \`manual\` (human approval)
+   - max_turns: 50 (default), up to 100 for complex tasks
+
+4) CREATE:
+   \`orch agent add "<name>" --adapter claude --model <model> --skills "<skills>" --role "<role>" --approval-policy auto\`
+
+## AVAILABLE SKILLS
+
+Development: feature-dev:feature-dev, feature-dev:code-explorer, feature-dev:code-architect, feature-dev:code-reviewer, simplify, claude-api
+Testing: testing-suite:generate-tests, testing-suite:test-coverage, testing-suite:e2e-setup, testing-suite:test-quality-analyzer
+Frontend: frontend-design, document-skills:frontend-design
+Documents: pdf, xlsx, docx, pptx
+Marketing: marketing-psychology, product-manager-toolkit
+
+## ANTI-PATTERNS
+
+- Never create agents without skills \u2014 they cannot be auto-matched to tasks.
+- Never write generic roles like "helper" \u2014 be specific about actions and tools.
+- Never use opus for simple tasks \u2014 it is expensive; use sonnet or haiku.
+- Never assign more than 3-4 skills per agent \u2014 create specialized agents instead.
+- Never use the -e/--edit flag in automated mode \u2014 it opens an interactive editor.
+- Always specify --role when calling \`orch agent add\`.
+
+After creation \u2014 \`orch context set agent-<name> "<capabilities>"\`.`;
+function getDefaultAgents() {
+  return [
+    {
+      id: "agt_creator",
+      name: "Agent Creator",
+      adapter: "claude",
+      role: AGENT_CREATOR_ROLE,
+      config: {
+        model: "claude-sonnet-4-6",
+        approval_policy: "suggest",
+        max_turns: 50,
+        timeout_ms: 36e5,
+        stall_timeout_ms: 3e5,
+        skills: ["document-skills:skill-creator"]
+      },
+      status: "idle",
+      stats: {
+        tasks_completed: 0,
+        tasks_failed: 0,
+        total_runs: 0,
+        total_runtime_ms: 0
+      }
+    }
+  ];
+}
+
+// src/cli/commands/init.ts
+async function runInit(opts = {}) {
+  const projectRoot = process.cwd();
+  const paths = new Paths(projectRoot);
+  if (await pathExists(paths.root)) {
+    printWarning("Already initialized");
+    return;
+  }
+  await Promise.all([
+    ensureDir(paths.tasksDir),
+    ensureDir(paths.agentsDir),
+    ensureDir(paths.goalsDir),
+    ensureDir(paths.runsDir),
+    ensureDir(paths.templatesDir),
+    ensureDir(paths.logsDir)
+  ]);
+  const config = { ...DEFAULT_CONFIG };
+  config.project.name = opts.name ?? path.basename(projectRoot);
+  const gitignoreContent = [
+    "# Runtime state",
+    "state.json",
+    "*.lock",
+    "",
+    "# Logs and runs",
+    "runs/",
+    "logs/",
+    "",
+    "# Agent workspaces",
+    "workspaces/"
+  ].join("\n") + "\n";
+  const excludeContent = [
+    ".orchestry",
+    "node_modules",
+    ".env",
+    ".env.*",
+    "dist",
+    "build",
+    ".next",
+    "__pycache__",
+    "*.pyc",
+    ".venv"
+  ].join("\n") + "\n";
+  const defaultAgents = getDefaultAgents();
+  await Promise.all([
+    writeYaml(paths.configPath, config),
+    atomicWrite(paths.gitignorePath, gitignoreContent),
+    atomicWrite(paths.workspaceExcludePath, excludeContent),
+    atomicWrite(paths.defaultTemplatePath(), DEFAULT_PROMPT_TEMPLATE),
+    ...defaultAgents.map((agent) => writeYaml(paths.agentPath(agent.id), agent))
+  ]);
+  await ensureRootGitignore(projectRoot);
+  console.log();
+  printSuccess("initialized");
+  console.log();
+  console.log(`  Created ${dim(".orchestry/")}`);
+  console.log(`  ${dim("\u251C\u2500\u2500")} config.yml`);
+  console.log(`  ${dim("\u251C\u2500\u2500")} tasks/`);
+  console.log(`  ${dim("\u251C\u2500\u2500")} agents/`);
+  for (const agent of defaultAgents) {
+    console.log(`  ${dim("\u2502   \u2514\u2500\u2500")} ${agent.id}.yml ${dim(`(${agent.name})`)}`);
+  }
+  console.log(`  ${dim("\u251C\u2500\u2500")} templates/default.md`);
+  console.log(`  ${dim("\u2514\u2500\u2500")} .gitignore`);
+  console.log();
+}
+async function ensureRootGitignore(projectRoot) {
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  try {
+    const content = await fs.readFile(gitignorePath, "utf-8");
+    if (content.split("\n").some((line) => line.trim() === ".orchestry")) return;
+    const separator = content.endsWith("\n") ? "" : "\n";
+    await fs.appendFile(gitignorePath, `${separator}
+# Orchestry state
+.orchestry
+`);
+  } catch {
+    await atomicWrite(gitignorePath, "# Orchestry state\n.orchestry\n");
+  }
+}
+function registerInitCommand(program) {
+  program.command("init").description("Initialize .orchestry/ in the current directory").option("--name <name>", "Project name").action(async (opts) => {
+    await runInit(opts);
+    console.log(`  Next: ${dim('orch task add "Create backend agent" --assignee agt_creator')}`);
+    console.log();
+  });
+}
+
+export { registerInitCommand, runInit };

package/dist/logs-PHPYWQ6I.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+import { printError, dim, getIcon } from './chunk-7X2GI5OV.js';
+import { InvalidArgumentsError } from './chunk-2C2TFQ7K.js';
+
+// src/cli/commands/logs.ts
+function registerLogsCommand(program, container) {
+  program.command("logs [run-id]").description("View run logs").option("--agent <agent-id>", "Filter by agent").option("--task <task-id>", "Filter by task").option("--follow", "Live stream").option("--since <duration>", "Filter by time (e.g. 5m, 1h)").action(async (runId, opts) => {
+    await container.paths.requireInit();
+    const sinceMs = opts.since ? parseDuration(opts.since) : void 0;
+    if (opts.follow) {
+      await followLive(container, { runId, taskId: opts.task, agentId: opts.agent });
+    } else if (runId) {
+      await showRunLogs(container, runId, sinceMs);
+    } else if (opts.task) {
+      await showTaskLogs(container, opts.task, sinceMs);
+    } else if (opts.agent) {
+      await showAgentLogs(container, opts.agent, sinceMs);
+    } else {
+      printError("Specify a run ID, --task, or --agent");
+      process.exit(2);
+    }
+  });
+}
+function formatEvent(event) {
+  const time = new Date(event.timestamp).toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const icon = event.type === "error" ? getIcon("failed") : getIcon("agentAction");
+  const data = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
+  return `  ${dim(time)}  ${icon} ${data.slice(0, 80)}`;
+}
+function filterBySince(events, sinceMs) {
+  if (!sinceMs) return events;
+  const cutoff = Date.now() - sinceMs;
+  return events.filter((e) => new Date(e.timestamp).getTime() >= cutoff);
+}
+async function showRunLogs(container, runId, sinceMs) {
+  let events = sinceMs ? filterBySince(await container.runService.readEventsTail(runId, 500), sinceMs) : await container.runService.readEventsTail(runId, 50);
+  if (container.context.json) {
+    console.log(JSON.stringify(events, null, 2));
+    return;
+  }
+  if (events.length === 0) {
+    console.log(`
+  No events for run ${runId}
+`);
+    return;
+  }
+  console.log();
+  for (const event of events) {
+    console.log(formatEvent(event));
+  }
+  console.log();
+}
+async function showTaskLogs(container, taskId, sinceMs) {
+  const runs = await container.runService.listForTask(taskId);
+  if (container.context.json) {
+    console.log(JSON.stringify(runs, null, 2));
+    return;
+  }
+  if (runs.length === 0) {
+    console.log(`
+  No runs for task ${taskId}
+`);
+    return;
+  }
+  const recentRuns = sinceMs ? runs.slice(-20) : runs;
+  const eventsPerRun = await Promise.all(
+    recentRuns.map(
+      (run) => sinceMs ? container.runService.readEventsTail(run.id, 500).then((e) => filterBySince(e, sinceMs)) : container.runService.readEventsTail(run.id, 10)
+    )
+  );
+  for (let i = 0; i < recentRuns.length; i++) {
+    const run = recentRuns[i];
+    const events = eventsPerRun[i];
+    console.log(`
+  Run ${run.id} \xB7 attempt ${run.attempt} \xB7 ${run.status}`);
+    for (const event of events.slice(-10)) {
+      console.log(formatEvent(event));
+    }
+  }
+  console.log();
+}
+async function showAgentLogs(container, agentId, sinceMs) {
+  const runs = await container.runService.listForAgent(agentId);
+  if (container.context.json) {
+    console.log(JSON.stringify(runs, null, 2));
+    return;
+  }
+  if (runs.length === 0) {
+    console.log(`
+  No runs for agent ${agentId}
+`);
+    return;
+  }
+  const recentRuns = runs.slice(-5);
+  const eventsPerRun = await Promise.all(
+    recentRuns.map(
+      (run) => sinceMs ? container.runService.readEventsTail(run.id, 500).then((e) => filterBySince(e, sinceMs)) : container.runService.readEventsTail(run.id, 5)
+    )
+  );
+  for (let i = 0; i < recentRuns.length; i++) {
+    const run = recentRuns[i];
+    const events = eventsPerRun[i];
+    console.log(`
+  Run ${run.id} \xB7 task ${run.task_id} \xB7 ${run.status}`);
+    for (const event of events.slice(-5)) {
+      console.log(formatEvent(event));
+    }
+  }
+  console.log();
+}
+async function followLive(container, filter) {
+  const runIds = /* @__PURE__ */ new Set();
+  const agentIds = /* @__PURE__ */ new Set();
+  if (filter.runId) {
+    runIds.add(filter.runId);
+  }
+  if (filter.taskId) {
+    const runs = await container.runService.listForTask(filter.taskId);
+    for (const r of runs) runIds.add(r.id);
+  }
+  if (filter.agentId) {
+    agentIds.add(filter.agentId);
+  }
+  const hasFilter = runIds.size > 0 || agentIds.size > 0;
+  console.log(`
+  ${dim("Following live events...")} ${dim("(Ctrl+C to stop)")}
+`);
+  const unsub = container.eventBus.onAny((event) => {
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    if (hasFilter) {
+      if ("runId" in event && runIds.size > 0 && !runIds.has(event.runId)) return;
+      if ("agentId" in event && agentIds.size > 0) {
+        const evt = event;
+        if (!agentIds.has(evt.agentId)) return;
+      }
+    }
+    switch (event.type) {
+      case "agent:output": {
+        const data = typeof event.data === "string" ? event.data.slice(0, 80) : "";
+        console.log(`  ${dim(time)}  ${getIcon("agentAction")} ${data}`);
+        break;
+      }
+      case "agent:file_changed":
+        console.log(`  ${dim(time)}  ${getIcon("agentAction")} Modified ${event.path}`);
+        break;
+      case "agent:error":
+        console.log(`  ${dim(time)}  ${getIcon("failed")} ${event.error}`);
+        break;
+      case "agent:started":
+        console.log(`  ${dim(time)}  ${getIcon("orchestratorEvent")} Started ${event.runId} (agent: ${event.agentId})`);
+        break;
+      case "agent:completed":
+        if (event.success) {
+          console.log(`  ${dim(time)}  ${getIcon("done")} DONE  ${event.runId}`);
+        } else {
+          console.log(`  ${dim(time)}  ${getIcon("failed")} FAIL  ${event.runId}`);
+        }
+        break;
+      case "run:retry":
+        console.log(`  ${dim(time)}  ${getIcon("retrying")} RETRY  attempt ${event.attempt} \xB7 next in ${Math.round(event.delay_ms / 1e3)}s`);
+        break;
+      case "orchestrator:stall_detected":
+        console.log(`  ${dim(time)}  ${getIcon("warning")} STALL  ${event.runId}`);
+        break;
+    }
+  });
+  await new Promise((resolve) => {
+    const cleanup = () => {
+      unsub();
+      resolve();
+    };
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+  });
+}
+function parseDuration(input) {
+  const match = input.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) {
+    throw new InvalidArgumentsError(`Invalid duration: "${input}". Use format: 5m, 1h, 30s, 1d`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 6e4;
+    case "h":
+      return value * 36e5;
+    case "d":
+      return value * 864e5;
+    default:
+      return value * 6e4;
+  }
+}
+
+export { registerLogsCommand };

package/dist/msg-FUWWLEKM.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { printSuccess, dim, formatDurationSince, printTable } from './chunk-7X2GI5OV.js';
+
+// src/cli/commands/msg.ts
+function registerMsgCommand(program, container) {
+  const msg = program.command("msg").description("Inter-agent messaging");
+  msg.command("send <to-agent-id> <body>").description("Send a direct message to an agent").option("-s, --subject <subject>", "Message subject").option("--from <agent-id>", "Sender agent ID (default: cli)").option("--ttl <ms>", "TTL in milliseconds").option("--reply-to <msg-id>", "Reply to a message").action(async (toAgentId, body, opts) => {
+    await container.paths.requireInit();
+    const messages = await container.messageService.send({
+      channel: "direct",
+      from_agent_id: opts.from ?? "cli",
+      to_agent_id: toAgentId,
+      subject: opts.subject ?? "",
+      body,
+      ttl_ms: opts.ttl ? parseInt(opts.ttl, 10) : void 0,
+      reply_to: opts.replyTo
+    });
+    if (container.context.json) {
+      console.log(JSON.stringify(messages, null, 2));
+    } else if (container.context.quiet) {
+      console.log(messages[0]?.id);
+    } else {
+      printSuccess(`Message sent: ${messages[0]?.id} \u2192 ${toAgentId}`);
+    }
+  });
+  msg.command("broadcast <body>").description("Broadcast a message to all agents (or team members)").option("-s, --subject <subject>", "Message subject").option("--from <agent-id>", "Sender agent ID (default: cli)").option("--team <team-id>", "Limit broadcast to team members").option("--ttl <ms>", "TTL in milliseconds").action(async (body, opts) => {
+    await container.paths.requireInit();
+    const messages = await container.messageService.send({
+      channel: "broadcast",
+      from_agent_id: opts.from ?? "cli",
+      subject: opts.subject ?? "",
+      body,
+      ttl_ms: opts.ttl ? parseInt(opts.ttl, 10) : void 0,
+      team_id: opts.team
+    });
+    if (container.context.json) {
+      console.log(JSON.stringify(messages, null, 2));
+    } else if (container.context.quiet) {
+      console.log(messages.map((m) => m.id).join("\n"));
+    } else {
+      printSuccess(`Broadcast sent to ${messages.length} agent(s)`);
+    }
+  });
+  msg.command("inbox <agent-id>").description("Show pending messages for an agent").action(async (agentId) => {
+    await container.paths.requireInit();
+    const pending = await container.messageService.listPendingForAgent(agentId);
+    if (container.context.json) {
+      console.log(JSON.stringify(pending, null, 2));
+      return;
+    }
+    if (pending.length === 0) {
+      console.log(dim("\n  No pending messages.\n"));
+      return;
+    }
+    console.log();
+    for (const m of pending) {
+      console.log(`  ${dim(m.id)} from ${m.from_agent_id}${m.subject ? ` \u2014 ${m.subject}` : ""}`);
+      console.log(`  ${m.body}`);
+      console.log();
+    }
+  });
+  msg.command("list").description("List all messages").option("--agent <agent-id>", "Filter by agent (sent or received)").action(async (opts) => {
+    await container.paths.requireInit();
+    let messages;
+    if (opts.agent) {
+      messages = await container.messageService.listForAgent(opts.agent);
+    } else {
+      messages = await container.messageService.listAll();
+    }
+    if (container.context.json) {
+      console.log(JSON.stringify(messages, null, 2));
+      return;
+    }
+    if (messages.length === 0) {
+      console.log(dim("\n  No messages.\n"));
+      return;
+    }
+    const headers = ["ID", "FROM", "TO", "CHANNEL", "STATUS", "SENT"];
+    const rows = messages.map((m) => [
+      m.id,
+      m.from_agent_id,
+      m.to_agent_id ?? "*",
+      m.channel,
+      m.status,
+      formatDurationSince(m.created_at)
+    ]);
+    console.log();
+    printTable(headers, rows);
+    console.log(`
+  ${messages.length} message(s)
+`);
+  });
+}
+
+export { registerMsgCommand };

package/dist/orchestrator-ADO66XZ3.js

@@ -0,0 +1,5 @@
+export { Orchestrator } from './chunk-VMDQVRBR.js';
+import './chunk-B4JQM4NU.js';
+import './chunk-NLQAJ7TW.js';
+//# sourceMappingURL=orchestrator-ADO66XZ3.js.map
+//# sourceMappingURL=orchestrator-ADO66XZ3.js.map

package/dist/{orchestrator-KF4UY5GD.js.map → orchestrator-ADO66XZ3.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"orchestrator-KF4UY5GD.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"orchestrator-ADO66XZ3.js"}