@oxgeneral/orch 0.3.3 → 1.0.0

package/dist/chunk-LV6GDBBI.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import { NotInitializedError } from './chunk-2C2TFQ7K.js';
+import { randomBytes } from 'crypto';
+import fs from 'fs/promises';
+import path2 from 'path';
+import yaml from 'js-yaml';
+import { accessSync } from 'fs';
+
+async function atomicWrite(filePath, content) {
+  const dir = path2.dirname(filePath);
+  await ensureDir(dir);
+  const tmpPath = path2.join(dir, `.${path2.basename(filePath)}.${randomBytes(4).toString("hex")}.tmp`);
+  try {
+    await fs.writeFile(tmpPath, content, "utf-8");
+    await fs.rename(tmpPath, filePath);
+  } catch (err) {
+    await fs.unlink(tmpPath).catch(() => {
+    });
+    throw err;
+  }
+}
+async function readYaml(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return yaml.load(content);
+  } catch (err) {
+    if (isENOENT(err)) return null;
+    throw err;
+  }
+}
+async function writeYaml(filePath, data) {
+  const content = yaml.dump(data, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  await atomicWrite(filePath, content);
+}
+async function readJson(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isENOENT(err)) return null;
+    throw err;
+  }
+}
+async function writeJson(filePath, data) {
+  const content = JSON.stringify(data, null, 2) + "\n";
+  await atomicWrite(filePath, content);
+}
+var PIPE_BUF = 4096;
+async function appendJsonl(filePath, record) {
+  const dir = path2.dirname(filePath);
+  await ensureDir(dir);
+  let line = JSON.stringify(record) + "\n";
+  const byteLen = Buffer.byteLength(line, "utf-8");
+  if (byteLen > PIPE_BUF && record !== null && typeof record === "object") {
+    const obj = record;
+    if (typeof obj.data === "string" && obj.data.length > 0) {
+      const shell = JSON.stringify({ ...obj, data: "" }) + "\n";
+      const overhead = Buffer.byteLength(shell, "utf-8");
+      const budget = PIPE_BUF - overhead - 3;
+      if (budget > 0) {
+        const truncated = obj.data.slice(0, budget);
+        line = JSON.stringify({ ...obj, data: truncated + "\u2026" }) + "\n";
+      }
+    }
+  }
+  const fd = await fs.open(filePath, "a");
+  try {
+    await fd.write(line, null, "utf-8");
+  } finally {
+    await fd.close();
+  }
+}
+var MAX_JSONL_READ_SIZE = 50 * 1024 * 1024;
+async function readJsonl(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.size > MAX_JSONL_READ_SIZE) {
+      process.stderr.write(
+        `[readJsonl] file too large (${(stat.size / 1024 / 1024).toFixed(1)} MB), reading tail only: ${filePath}
+`
+      );
+      return readJsonlTail(filePath, 200);
+    }
+    return readAndParseJsonl(filePath);
+  } catch (err) {
+    if (isENOENT(err)) return [];
+    throw err;
+  }
+}
+async function readJsonlTail(filePath, count) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.size < 32768) {
+      return (await readAndParseJsonl(filePath)).slice(-count);
+    }
+    const fd = await fs.open(filePath, "r");
+    try {
+      const chunkSize = Math.min(stat.size, stat.size > 1048576 ? 131072 : 65536);
+      let position = Math.max(0, stat.size - chunkSize);
+      let earliestReadPosition = position;
+      let tail = "";
+      for (let attempt = 0; attempt < 4 && position >= 0; attempt++) {
+        earliestReadPosition = position;
+        const readSize = Math.min(chunkSize, stat.size - position);
+        const buf = Buffer.alloc(readSize);
+        await fd.read(buf, 0, readSize, position);
+        tail = buf.toString("utf-8") + tail;
+        const lines2 = tail.split("\n").filter((l) => l.trim().length > 0);
+        if (lines2.length >= count + 1) {
+          return parseJsonlLines(lines2.slice(-count));
+        }
+        if (position === 0) break;
+        position = Math.max(0, position - chunkSize);
+      }
+      const lines = tail.split("\n").filter((l) => l.trim().length > 0);
+      const safeLines = earliestReadPosition > 0 ? lines.slice(1) : lines;
+      return parseJsonlLines(safeLines.slice(-count));
+    } finally {
+      await fd.close();
+    }
+  } catch (err) {
+    if (isENOENT(err)) return [];
+    throw err;
+  }
+}
+async function readAndParseJsonl(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  return parseJsonlLines(lines);
+}
+function parseJsonlLines(lines) {
+  const results = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+      process.stderr.write(`[readJsonl] skipping corrupt line: ${line.slice(0, 200)}
+`);
+    }
+  }
+  return results;
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listFiles(dirPath, ext) {
+  try {
+    const entries = await fs.readdir(dirPath);
+    if (ext) {
+      return entries.filter((e) => e.endsWith(ext));
+    }
+    return entries;
+  } catch (err) {
+    if (isENOENT(err)) return [];
+    throw err;
+  }
+}
+function isENOENT(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+var ORCHESTRY_DIR = ".orchestry";
+var ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+var Paths = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /** Root .orchestry/ directory */
+  get root() {
+    return path2.join(this.projectRoot, ORCHESTRY_DIR);
+  }
+  get configPath() {
+    return path2.join(this.root, "config.yml");
+  }
+  get statePath() {
+    return path2.join(this.root, "state.json");
+  }
+  get lockPath() {
+    return path2.join(this.root, "orchestry.lock");
+  }
+  get tasksDir() {
+    return path2.join(this.root, "tasks");
+  }
+  get agentsDir() {
+    return path2.join(this.root, "agents");
+  }
+  get runsDir() {
+    return path2.join(this.root, "runs");
+  }
+  get templatesDir() {
+    return path2.join(this.root, "templates");
+  }
+  get logsDir() {
+    return path2.join(this.root, "logs");
+  }
+  get contextDir() {
+    return path2.join(this.root, "context");
+  }
+  contextPath(key) {
+    return path2.join(this.contextDir, `${sanitizeId(key)}.json`);
+  }
+  get messagesDir() {
+    return path2.join(this.root, "messages");
+  }
+  messagePath(id) {
+    return path2.join(this.messagesDir, `${sanitizeId(id)}.json`);
+  }
+  get goalsDir() {
+    return path2.join(this.root, "goals");
+  }
+  goalPath(id) {
+    return path2.join(this.goalsDir, `${sanitizeId(id)}.yml`);
+  }
+  get teamsDir() {
+    return path2.join(this.root, "teams");
+  }
+  get attachmentsDir() {
+    return path2.join(this.root, "attachments");
+  }
+  taskAttachmentsDir(taskId) {
+    return path2.join(this.attachmentsDir, sanitizeId(taskId));
+  }
+  teamPath(id) {
+    return path2.join(this.teamsDir, `${sanitizeId(id)}.yml`);
+  }
+  get gitignorePath() {
+    return path2.join(this.root, ".gitignore");
+  }
+  get workspaceExcludePath() {
+    return path2.join(this.root, "workspace-exclude");
+  }
+  taskPath(id) {
+    return path2.join(this.tasksDir, `${sanitizeId(id)}.yml`);
+  }
+  agentPath(id) {
+    return path2.join(this.agentsDir, `${sanitizeId(id)}.yml`);
+  }
+  runPath(id) {
+    return path2.join(this.runsDir, `${sanitizeId(id)}.json`);
+  }
+  runEventsPath(id) {
+    return path2.join(this.runsDir, `${sanitizeId(id)}.jsonl`);
+  }
+  defaultTemplatePath() {
+    return path2.join(this.templatesDir, "default.md");
+  }
+  async isInitialized() {
+    return pathExists(this.root);
+  }
+  async requireInit() {
+    if (!await this.isInitialized()) {
+      throw new NotInitializedError();
+    }
+  }
+};
+function sanitizeId(id) {
+  if (!ID_PATTERN.test(id)) {
+    throw new Error(`Invalid identifier: "${id}"`);
+  }
+  return id;
+}
+function validateWorkspacePath(workspacePath, projectRoot) {
+  const resolved = path2.resolve(workspacePath);
+  const root = path2.resolve(projectRoot);
+  if (!resolved.startsWith(root + path2.sep) && resolved !== root) {
+    throw new Error(`Workspace path "${workspacePath}" is outside project root`);
+  }
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = path2.resolve(startDir);
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    try {
+      accessSync(path2.join(dir, ".orchestry"));
+      return dir;
+    } catch {
+    }
+    dir = path2.dirname(dir);
+  }
+  return startDir;
+}
+
+export { Paths, appendJsonl, atomicWrite, ensureDir, findProjectRoot, listFiles, pathExists, readJson, readJsonl, readJsonlTail, readYaml, sanitizeId, validateWorkspacePath, writeJson, writeYaml };

package/dist/chunk-MGGSRXWJ.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { classifyAdapterError } from './chunk-2C2TFQ7K.js';
+import { readLines } from './chunk-CHIP7O6V.js';
+
+// src/domain/run.ts
+function createTokenUsage(input, output) {
+  return { input, output, total: input + output };
+}
+
+// src/infrastructure/adapters/utils.ts
+function buildFullPrompt(systemPrompt, userPrompt) {
+  return systemPrompt ? systemPrompt + "\n\n" + userPrompt : userPrompt;
+}
+function extractTokens(parsed, opts) {
+  let usage = parsed.usage;
+  if (!usage && opts?.statsFallback) {
+    const stats = parsed.stats;
+    usage = stats?.usage;
+  }
+  if (usage && typeof usage.input_tokens === "number") {
+    const input = usage.input_tokens;
+    const output = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+    return createTokenUsage(input, output);
+  }
+  return void 0;
+}
+function createStreamingEvents(proc, parseEvent, adapterName, signal) {
+  async function* generate() {
+    let gotDoneEvent = false;
+    let exitCode = null;
+    let exitError = null;
+    const exitPromise = new Promise((resolve) => {
+      proc.on("close", (code) => {
+        exitCode = code;
+        resolve();
+      });
+      proc.on("error", (err) => {
+        exitError = err;
+        resolve();
+      });
+    });
+    if (proc.stdout) {
+      for await (const line of readLines(proc.stdout)) {
+        if (signal?.aborted) break;
+        const event = parseEvent(line);
+        if (event) {
+          if (event.type === "done") gotDoneEvent = true;
+          yield event;
+        }
+      }
+    }
+    await exitPromise;
+    if (exitError && !signal?.aborted && !gotDoneEvent) {
+      const spawnErr = exitError;
+      const classified = classifyAdapterError(spawnErr.message, exitCode ?? void 0);
+      const err = Object.assign(new Error(spawnErr.message), { errorKind: classified });
+      throw err;
+    }
+    if (exitCode !== 0 && exitCode !== null && !signal?.aborted && !gotDoneEvent) {
+      const msg = `${adapterName} process exited with code ${exitCode}`;
+      const classified = classifyAdapterError(msg, exitCode);
+      const err = Object.assign(new Error(msg), { errorKind: classified });
+      throw err;
+    }
+  }
+  return generate();
+}
+
+export { buildFullPrompt, createStreamingEvents, createTokenUsage, extractTokens };

package/dist/chunk-P6ATSXGL.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { mkdtemp, writeFile, readFile, unlink, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { spawn } from 'child_process';
+
+async function openInEditor(initialContent, opts = {}) {
+  const { extension = ".yml", prefix = "orch-" } = opts;
+  const editor = process.env["EDITOR"] || process.env["VISUAL"] || "vi";
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  const filePath = join(dir, `edit${extension}`);
+  await writeFile(filePath, initialContent, "utf8");
+  try {
+    const parts = editor.split(/\s+/);
+    const child = spawn(parts[0], [...parts.slice(1), filePath], { stdio: "inherit" });
+    await new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Editor exited with code ${code}`));
+      });
+      child.on("error", reject);
+    });
+    return await readFile(filePath, "utf8");
+  } finally {
+    await unlink(filePath).catch(() => {
+    });
+    await rm(dir, { recursive: true }).catch(() => {
+    });
+  }
+}
+function toEditorContent(fields) {
+  const lines = [
+    "---",
+    `title: ${fields.title}`,
+    `priority: ${fields.priority}`,
+    "---",
+    "",
+    fields.description ?? ""
+  ];
+  return lines.join("\n");
+}
+function fromEditorContent(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    return { description: content.trim() || void 0 };
+  }
+  const frontmatter = match[1] ?? "";
+  const body = match[2] ?? "";
+  const result = {};
+  for (const line of frontmatter.split("\n")) {
+    const kv = line.match(/^([\w]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const value = kv[2] ?? "";
+    if (key === "title" && value.trim()) {
+      result.title = value.trim();
+    } else if (key === "priority") {
+      const n = parseInt(value.trim(), 10);
+      if (n >= 1 && n <= 4) result.priority = n;
+    }
+  }
+  const desc = body.trim();
+  if (desc) result.description = desc;
+  return result;
+}
+function agentToEditorContent(fields) {
+  const lines = [
+    "# Edit agent configuration.",
+    "# Lines starting with # are ignored.",
+    "# Role description goes below the second --- separator.",
+    "---",
+    `name: ${fields.name}`,
+    `model: ${fields.model ?? ""}`,
+    "---",
+    "",
+    fields.role ?? ""
+  ];
+  return lines.join("\n");
+}
+function agentFromEditorContent(content) {
+  const lines = content.split("\n");
+  const firstFence = lines.findIndex((l) => l.trimEnd() === "---");
+  const stripped = (firstFence >= 0 ? [...lines.slice(0, firstFence).filter((l) => !l.startsWith("#")), ...lines.slice(firstFence)] : lines.filter((l) => !l.startsWith("#"))).join("\n");
+  const match = stripped.trimStart().match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    const role = stripped.trim();
+    return { role: role || void 0 };
+  }
+  const frontmatter = match[1] ?? "";
+  const body = match[2] ?? "";
+  const result = {};
+  for (const line of frontmatter.split("\n")) {
+    const kv = line.match(/^([\w]+):\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const value = kv[2] ?? "";
+    if (key === "name") {
+      result.name = value.trim();
+    } else if (key === "model") {
+      result.model = value.trim();
+    }
+  }
+  result.role = body.trim();
+  return result;
+}
+
+export { agentFromEditorContent, agentToEditorContent, fromEditorContent, openInEditor, toEditorContent };

package/dist/chunk-PNE6LQRF.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// src/domain/task.ts
+var AUTONOMOUS_LABEL = "autonomous";
+
+export { AUTONOMOUS_LABEL };

package/dist/chunk-U2VDNUZL.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// src/domain/transitions.ts
+var VALID_TRANSITIONS = {
+  todo: ["in_progress", "cancelled"],
+  in_progress: ["review", "retrying", "failed", "cancelled"],
+  retrying: ["in_progress", "failed", "cancelled"],
+  review: ["done", "todo", "cancelled"],
+  done: [],
+  failed: ["todo", "retrying"],
+  cancelled: ["todo"]
+};
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
+function canTransition(from, to) {
+  return VALID_TRANSITIONS[from].includes(to);
+}
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function isDispatchable(status) {
+  return status === "todo" || status === "retrying";
+}
+function isBlocked(task, allTasks) {
+  if (task.depends_on.length === 0) return false;
+  if (allTasks instanceof Map) {
+    return task.depends_on.some((depId) => {
+      const dep = allTasks.get(depId);
+      return !dep || dep.status !== "done";
+    });
+  }
+  return task.depends_on.some((depId) => {
+    const dep = allTasks.find((t) => t.id === depId);
+    return !dep || dep.status !== "done";
+  });
+}
+function resolveFailureStatus(task) {
+  if (task.attempts < task.max_attempts) {
+    return "retrying";
+  }
+  return "failed";
+}
+function resolveCompletionStatus(task, success, _autoApprove) {
+  if (success) {
+    return "review";
+  }
+  return resolveFailureStatus(task);
+}
+function calculateRetryDelay(attempt, baseDelayMs, maxDelayMs) {
+  const delay = baseDelayMs * Math.pow(2, attempt);
+  return Math.min(delay, maxDelayMs);
+}
+
+export { calculateRetryDelay, canTransition, isBlocked, isDispatchable, isTerminal, resolveCompletionStatus, resolveFailureStatus };