@oxgeneral/orch 0.3.3 → 0.3.4

package/dist/chunk-7X2GI5OV.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+
+var icons = {
+  running: "\u25CF",
+  todo: "\u25CB",
+  review: "\u25C8",
+  done: "\u2713",
+  failed: "\u2715",
+  retrying: "\u21BB",
+  cancelled: "\u25CB",
+  idle: "\u25CB",
+  error: "\u2715",
+  disabled: "\u2500",
+  agentAction: "\u25B8",
+  orchestratorEvent: "\u2192",
+  warning: "\u26A0"
+};
+var asciiIcons = {
+  running: "*",
+  todo: "o",
+  review: "#",
+  done: "+",
+  failed: "x",
+  retrying: "~",
+  cancelled: "o",
+  idle: "o",
+  error: "x",
+  disabled: "-",
+  agentAction: ">",
+  orchestratorEvent: "->",
+  warning: "!!"
+};
+var COLOR_CODES = {
+  amber: 214,
+  green: 72,
+  red: 167,
+  blue: 74,
+  yellow: 178,
+  dim: 240,
+  ghost: 236,
+  white: 255,
+  purple: 141
+};
+var _colors;
+function getColors() {
+  if (!_colors) {
+    _colors = {};
+    for (const [name, code] of Object.entries(COLOR_CODES)) {
+      _colors[name] = chalk.ansi256(code);
+    }
+  }
+  return _colors;
+}
+var colors = new Proxy({}, {
+  get(_target, prop) {
+    return getColors()[prop];
+  }
+});
+var useAscii = false;
+function setAsciiMode(ascii) {
+  useAscii = ascii;
+}
+function setNoColor(noColor) {
+  if (noColor) {
+    chalk.level = 0;
+  }
+}
+function getIcon(name) {
+  return useAscii ? asciiIcons[name] : icons[name];
+}
+function statusIcon(status) {
+  const icon = getIcon(status);
+  switch (status) {
+    case "running":
+    case "in_progress":
+      return colors.green(getIcon("running"));
+    case "todo":
+      return colors.dim(getIcon("todo"));
+    case "review":
+      return colors.blue(getIcon("review"));
+    case "done":
+      return colors.green(getIcon("done"));
+    case "failed":
+      return colors.red(getIcon("failed"));
+    case "retrying":
+      return colors.yellow(getIcon("retrying"));
+    case "cancelled":
+      return colors.dim(getIcon("cancelled"));
+    case "idle":
+      return colors.dim(getIcon("idle"));
+    case "error":
+      return colors.red(getIcon("error"));
+    case "disabled":
+      return colors.ghost(getIcon("disabled"));
+    default:
+      return icon;
+  }
+}
+function priorityLabel(priority) {
+  switch (priority) {
+    case 1:
+      return colors.red("P1");
+    case 2:
+      return colors.yellow("P2");
+    case 3:
+      return "P3";
+    case 4:
+      return colors.dim("P4");
+    default:
+      return `P${priority}`;
+  }
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  if (minutes < 60) return `${minutes}:${String(secs).padStart(2, "0")}`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return `${hours}h${String(mins).padStart(2, "0")}m`;
+}
+function formatDurationSince(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  return formatDuration(ms);
+}
+function formatTokens(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function printError(message, hint) {
+  console.error(`  ${colors.red(getIcon("failed"))} ${message}`);
+  if (hint) {
+    console.error(`    ${hint}`);
+  }
+}
+function printSuccess(message) {
+  console.log(`  ${colors.green(getIcon("done"))} ${message}`);
+}
+function printWarning(message) {
+  console.log(`  ${colors.yellow(getIcon("warning"))} ${message}`);
+}
+function printTable(headers, rows, padding = 2) {
+  const colWidths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i] + padding)).join("");
+  console.log(`  ${colors.dim(headerLine)}`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => {
+      const stripped = stripAnsi(cell);
+      const pad = (colWidths[i] ?? 0) + padding - stripped.length;
+      return cell + " ".repeat(Math.max(0, pad));
+    }).join("");
+    console.log(`  ${line}`);
+  }
+}
+function printKeyValue(pairs) {
+  const maxKey = Math.max(...pairs.map(([k]) => k.length));
+  for (const [key, value] of pairs) {
+    console.log(`  ${colors.dim(key.padEnd(maxKey + 2))}${value}`);
+  }
+}
+function filePath(p) {
+  return colors.purple(p);
+}
+function agentName(name) {
+  return colors.green(name);
+}
+function amber(text) {
+  return colors.amber(text);
+}
+function dim(text) {
+  return colors.dim(text);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+export { agentName, amber, dim, filePath, formatDuration, formatDurationSince, formatTokens, getIcon, printError, printKeyValue, printSuccess, printTable, printWarning, priorityLabel, setAsciiMode, setNoColor, statusIcon };

package/dist/{chunk-HSBYJ5C5.js → chunk-A36WAF2S.js}

@@ -1,5 +1,90 @@
 #!/usr/bin/env node
-import {a}from'./chunk-CHRW4CLD.js';var p=class{engine;renderTimeoutMs;constructor(s){this.renderTimeoutMs=s?.renderTimeoutMs??5e3;}async getEngine(){if(!this.engine){let{Liquid:s}=await import('liquidjs');this.engine=new s({strictFilters:false,strictVariables:false});}return this.engine}async render(s,o){let r=(await this.getEngine()).parseAndRender(s,o);if(this.renderTimeoutMs<=0)return r;let i,n=new Promise((g,a)=>{i=setTimeout(()=>a(new Error(`Template render timed out after ${this.renderTimeoutMs}ms`)),this.renderTimeoutMs);});try{return await Promise.race([r,n])}finally{clearTimeout(i);}}};function y(t,s,o,d,r,i){let{allAgents:n,retryContext:g,sharedContext:a$1,feedback:m,messages:l,goal:u}=i??{},f=new Map((n??[]).map(e=>[e.id,e])),h=l?.length?l.map(e=>({id:e.id,from:f.get(e.from_agent_id)?.name??e.from_agent_id,subject:e.subject,body:e.body,sent_at:e.created_at,reply_to:e.reply_to})):void 0;return {project:{name:r.project.name,description:r.project.description},task:{id:t.id,title:t.title,description:t.description,priority:t.priority,labels:t.labels,scope:t.scope,is_autonomous:t.labels?.includes(a)??false,goal_id:t.goalId},agent:{id:s.id,name:s.name,role:s.role},agents:(n??[]).map(e=>({id:e.id,name:e.name,role:e.role,adapter:e.adapter})),attempt:o>1?o:null,workspace_path:d,retry:o>1?g:void 0,feedback:m,shared_context:a$1&&Object.keys(a$1).length>0?a$1:void 0,messages:h,goal:u}}var b=`You are {{ agent.name }}{% if agent.role %} ({{ agent.role }}){% endif %}.
+import { AUTONOMOUS_LABEL } from './chunk-PNE6LQRF.js';
+
+// src/infrastructure/template/template-engine.ts
+var LiquidTemplateEngine = class {
+  engine;
+  renderTimeoutMs;
+  constructor(options) {
+    this.renderTimeoutMs = options?.renderTimeoutMs ?? 5e3;
+  }
+  async getEngine() {
+    if (!this.engine) {
+      const { Liquid } = await import('liquidjs');
+      this.engine = new Liquid({
+        strictFilters: false,
+        strictVariables: false
+      });
+    }
+    return this.engine;
+  }
+  async render(template, context) {
+    const engine = await this.getEngine();
+    const renderPromise = engine.parseAndRender(template, context);
+    if (this.renderTimeoutMs <= 0) {
+      return renderPromise;
+    }
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`Template render timed out after ${this.renderTimeoutMs}ms`)),
+        this.renderTimeoutMs
+      );
+    });
+    try {
+      return await Promise.race([renderPromise, timeoutPromise]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function buildPromptContext(task, agent, attempt, workspacePath, config, options) {
+  const { allAgents, retryContext, sharedContext, feedback, messages: rawMessages, goal } = options ?? {};
+  const agentById = new Map((allAgents ?? []).map((a) => [a.id, a]));
+  const messages = rawMessages?.length ? rawMessages.map((m) => ({
+    id: m.id,
+    from: agentById.get(m.from_agent_id)?.name ?? m.from_agent_id,
+    subject: m.subject,
+    body: m.body,
+    sent_at: m.created_at,
+    reply_to: m.reply_to
+  })) : void 0;
+  return {
+    project: {
+      name: config.project.name,
+      description: config.project.description
+    },
+    task: {
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      priority: task.priority,
+      labels: task.labels,
+      scope: task.scope,
+      is_autonomous: task.labels?.includes(AUTONOMOUS_LABEL) ?? false,
+      goal_id: task.goalId
+    },
+    agent: {
+      id: agent.id,
+      name: agent.name,
+      role: agent.role
+    },
+    agents: (allAgents ?? []).map((a) => ({
+      id: a.id,
+      name: a.name,
+      role: a.role,
+      adapter: a.adapter
+    })),
+    attempt: attempt > 1 ? attempt : null,
+    workspace_path: workspacePath,
+    retry: attempt > 1 ? retryContext : void 0,
+    feedback,
+    shared_context: sharedContext && Object.keys(sharedContext).length > 0 ? sharedContext : void 0,
+    messages,
+    goal
+  };
+}
+var DEFAULT_PROMPT_TEMPLATE = `You are {{ agent.name }}{% if agent.role %} ({{ agent.role }}){% endif %}.
 
 ## Task: {{ task.title }}
 {{ task.description }}
@@ -109,4 +194,6 @@ This is an autonomous task driven by a goal. Work in a continuous loop until the
 - If critical information is missing, document your assumptions and continue.
 - When a task is too large or spans multiple domains, break it into subtasks using \`orch task add\`.
 - When creating subtasks, use \`--scope\` to declare which files each task will touch, and \`--depends-on\` to order dependent work.
-`;export{p as a,y as b,b as c};
+`;
+
+export { DEFAULT_PROMPT_TEMPLATE, LiquidTemplateEngine, buildPromptContext };

package/dist/chunk-CHIP7O6V.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+
+var ProcessManager = class {
+  isAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      if (err.code === "EPERM") return true;
+      return false;
+    }
+  }
+  kill(pid, signal = "SIGTERM") {
+    try {
+      process.kill(-pid, signal);
+    } catch {
+      try {
+        process.kill(pid, signal);
+      } catch {
+      }
+    }
+  }
+  async killWithGrace(pid, graceMs = 1e4) {
+    if (!this.isAlive(pid)) return;
+    this.kill(pid, "SIGTERM");
+    const deadline = Date.now() + graceMs;
+    while (Date.now() < deadline) {
+      if (!this.isAlive(pid)) return;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    this.kill(pid, "SIGKILL");
+  }
+  spawn(command, args, options) {
+    const proc = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      // Create new process group so killWithGrace(-pid) kills all children
+      ...options
+    });
+    if (!proc.pid) {
+      throw new Error(`Failed to spawn process: ${command}`);
+    }
+    proc.unref();
+    return { process: proc, pid: proc.pid };
+  }
+};
+var MAX_LINE_LEN = 16384;
+function capLine(s) {
+  return s.length > MAX_LINE_LEN ? s.slice(0, MAX_LINE_LEN) : s;
+}
+async function* readLines(stream) {
+  const chunks = [];
+  let totalLen = 0;
+  for await (const chunk of stream) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf-8");
+    if (buf.length === 0) continue;
+    chunks.push(buf);
+    totalLen += buf.length;
+    const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, totalLen);
+    chunks.length = 0;
+    totalLen = 0;
+    let offset = 0;
+    let newlineIdx;
+    while ((newlineIdx = buffer.indexOf(10, offset)) !== -1) {
+      if (newlineIdx > offset) {
+        yield capLine(buffer.toString("utf-8", offset, newlineIdx));
+      }
+      offset = newlineIdx + 1;
+    }
+    if (offset < buffer.length) {
+      const remainder = buffer.subarray(offset);
+      chunks.push(remainder);
+      totalLen = remainder.length;
+    }
+  }
+  if (totalLen > 0) {
+    const final = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, totalLen);
+    yield capLine(final.toString("utf-8"));
+  }
+}
+
+export { ProcessManager, readLines };

package/dist/chunk-D6RFF3KN.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { createStreamingEvents, extractTokens } from './chunk-W6RSVMXR.js';
+import { classifyAdapterError } from './chunk-2C2TFQ7K.js';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+var execFileAsync = promisify(execFile);
+var ClaudeAdapter = class {
+  constructor(processManager) {
+    this.processManager = processManager;
+  }
+  kind = "claude";
+  async test() {
+    try {
+      const { stdout } = await execFileAsync("claude", ["--version"]);
+      return { ok: true, version: stdout.trim() };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        error: "Claude Code CLI not found. Install: npm i -g @anthropic-ai/claude-code",
+        errorKind: classifyAdapterError(msg)
+      };
+    }
+  }
+  execute(params) {
+    const args = [
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--max-turns",
+      String(params.config.max_turns ?? 50),
+      "--verbose",
+      "--dangerously-skip-permissions"
+      // Agents run autonomously; stdin is 'ignore' so prompts would hang
+    ];
+    if (params.config.model) {
+      args.push("--model", params.config.model);
+    }
+    if (params.config.system_prompt) {
+      args.push("--system-prompt", params.config.system_prompt);
+    }
+    args.push(params.prompt);
+    const { process: proc, pid } = this.processManager.spawn("claude", args, {
+      cwd: params.workspace,
+      env: { ...process.env, ...params.env },
+      signal: params.signal
+    });
+    const events = createStreamingEvents(proc, parseClaudeEvent, "Claude", params.signal);
+    return { pid, events };
+  }
+  async stop(pid) {
+    await this.processManager.killWithGrace(pid);
+  }
+};
+function parseClaudeEvent(line) {
+  if (!line.trim()) return null;
+  try {
+    const parsed = JSON.parse(line);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    switch (parsed.type) {
+      case "assistant":
+        return { type: "output", timestamp, data: parsed.message ?? parsed };
+      case "tool_use":
+        return { type: "tool_call", timestamp, data: parsed };
+      case "tool_result":
+        return { type: "output", timestamp, data: parsed };
+      case "error": {
+        const errData = parsed.error ?? parsed;
+        const errMsg = typeof errData === "string" ? errData : JSON.stringify(errData);
+        return { type: "error", timestamp, data: errData, errorKind: classifyAdapterError(errMsg) };
+      }
+      case "result": {
+        const tokens = extractTokens(parsed, { statsFallback: true });
+        return { type: "done", timestamp, data: parsed, tokens };
+      }
+      default:
+        return { type: "output", timestamp, data: parsed };
+    }
+  } catch {
+    return { type: "output", timestamp: (/* @__PURE__ */ new Date()).toISOString(), data: line };
+  }
+}
+
+export { ClaudeAdapter };