@oxgeneral/orch 1.0.1 → 1.0.3

package/dist/chunk-CHIP7O6V.js

@@ -1,83 +0,0 @@
-#!/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-FRTKB575.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { execFile } from 'child_process';
-
-var PACKAGE_NAME = "@oxgeneral/orch";
-var CACHE_DIR = path.join(os.homedir(), ".orchestry");
-var CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
-var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
-var REVALIDATE_AFTER_MS = CHECK_INTERVAL_MS * 0.75;
-function compareSemver(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
-    if (diff !== 0) return diff > 0 ? 1 : -1;
-  }
-  return 0;
-}
-async function readCache() {
-  try {
-    const raw = await fs.readFile(CACHE_FILE, "utf-8");
-    const data = JSON.parse(raw);
-    if (Date.now() - data.checked_at < CHECK_INTERVAL_MS) return data;
-  } catch {
-  }
-  return null;
-}
-async function writeCache(latest) {
-  await fs.mkdir(CACHE_DIR, { recursive: true });
-  const data = { latest, checked_at: Date.now() };
-  const tmp = `${CACHE_FILE}.tmp.${process.pid}`;
-  await fs.writeFile(tmp, JSON.stringify(data), "utf-8");
-  await fs.rename(tmp, CACHE_FILE);
-}
-function fetchLatestVersion() {
-  return new Promise((resolve) => {
-    const child = execFile("npm", ["view", PACKAGE_NAME, "version", "--json"], { timeout: 5e3 }, (err, stdout) => {
-      if (err) return resolve(null);
-      try {
-        resolve(JSON.parse(stdout.trim()));
-      } catch {
-        resolve(null);
-      }
-    });
-    child.unref();
-  });
-}
-function buildUpdateInfo(current, latest) {
-  return { current, latest, updateAvailable: compareSemver(latest, current) > 0 };
-}
-async function checkForUpdateNow(currentVersion) {
-  const latest = await fetchLatestVersion();
-  if (!latest) return null;
-  await writeCache(latest).catch(() => {
-  });
-  return buildUpdateInfo(currentVersion, latest);
-}
-async function checkForUpdateSWR(currentVersion) {
-  try {
-    const cached = await readCache();
-    if (!cached) {
-      checkForUpdateNow(currentVersion).catch(() => {
-      });
-      return null;
-    }
-    const age = Date.now() - cached.checked_at;
-    if (age >= REVALIDATE_AFTER_MS) {
-      checkForUpdateNow(currentVersion).catch(() => {
-      });
-    }
-    return buildUpdateInfo(currentVersion, cached.latest);
-  } catch {
-    return null;
-  }
-}
-function printUpdateNotification(info) {
-  if (!info.updateAvailable) return;
-  const msg = `
-  Update available: ${info.current} \u2192 ${info.latest}
-  Run: npm install -g ${PACKAGE_NAME}
-`;
-  process.stderr.write(msg);
-}
-
-export { checkForUpdateNow, checkForUpdateSWR, printUpdateNotification };

package/dist/chunk-HXYAZGLP.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-// src/domain/goal.ts
-var GOAL_STATUSES = ["active", "paused", "achieved", "abandoned"];
-var TERMINAL_GOAL_STATUSES = /* @__PURE__ */ new Set(["achieved", "abandoned"]);
-function isGoalTerminal(status) {
-  return TERMINAL_GOAL_STATUSES.has(status);
-}
-var GOAL_STATUS_ORDER = {
-  active: 0,
-  paused: 1,
-  achieved: 2,
-  abandoned: 3
-};
-
-export { GOAL_STATUSES, GOAL_STATUS_ORDER, isGoalTerminal };

package/dist/chunk-I3SMISEF.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-// src/domain/config.ts
-var DEFAULT_CONFIG = {
-  project: {
-    name: "my-project"
-  },
-  defaults: {
-    agent: {
-      adapter: "claude",
-      approval_policy: "auto",
-      max_turns: 50,
-      timeout_ms: 36e5,
-      stall_timeout_ms: 3e5,
-      workspace_mode: "worktree"
-    },
-    task: {
-      max_attempts: 3,
-      priority: 3
-    }
-  },
-  scheduling: {
-    poll_interval_ms: 1e4,
-    max_concurrent_agents: 6,
-    retry_base_delay_ms: 1e4,
-    retry_max_delay_ms: 3e5
-  }
-};
-
-export { DEFAULT_CONFIG };

package/dist/chunk-K6DMQERQ.js

@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs/promises';
-import path from 'path';
-
-var execFileAsync = promisify(execFile);
-var DoctorService = class {
-  constructor(adapterRegistry, processManager, projectRoot) {
-    this.adapterRegistry = adapterRegistry;
-    this.processManager = processManager;
-    this.cwd = projectRoot ?? process.cwd();
-  }
-  cwd;
-  async runAll() {
-    const checks = [];
-    const adapters = this.adapterRegistry.list();
-    let adaptersReady = 0;
-    for (const adapter of adapters) {
-      const result = await adapter.test();
-      if (result.ok) {
-        adaptersReady++;
-        checks.push({
-          name: adapter.kind,
-          status: "ok",
-          detail: result.version
-        });
-      } else {
-        checks.push({
-          name: adapter.kind,
-          status: "fail",
-          detail: result.error
-        });
-      }
-    }
-    checks.push(await this.checkCommand("git", ["--version"], "git"));
-    checks.push(await this.checkGitRepo());
-    checks.push(await this.checkGitignore());
-    checks.push(await this.checkCommand("node", ["--version"], "node"));
-    return {
-      checks,
-      adaptersReady,
-      adaptersTotal: adapters.length
-    };
-  }
-  async checkCommand(command, args, name) {
-    try {
-      const { stdout } = await execFileAsync(command, args);
-      return { name, status: "ok", detail: stdout.trim() };
-    } catch {
-      return { name, status: "fail", detail: `${command}: command not found` };
-    }
-  }
-  async checkGitignore() {
-    const gitignorePath = path.join(this.cwd, ".gitignore");
-    try {
-      const content = await fs.readFile(gitignorePath, "utf-8");
-      const hasEntry = content.split("\n").some((line) => line.trim() === ".orchestry");
-      if (hasEntry) {
-        return { name: ".gitignore", status: "ok", detail: ".orchestry is excluded" };
-      }
-      return {
-        name: ".gitignore",
-        status: "fail",
-        detail: ".orchestry not in .gitignore \u2014 worktrees will copy state recursively. Run: orch init"
-      };
-    } catch {
-      return {
-        name: ".gitignore",
-        status: "fail",
-        detail: "no .gitignore found \u2014 .orchestry may be committed to git. Run: orch init"
-      };
-    }
-  }
-  async checkGitRepo() {
-    try {
-      await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: this.cwd });
-      return { name: "git repo", status: "ok", detail: "git repository detected" };
-    } catch {
-      return {
-        name: "git repo",
-        status: "fail",
-        detail: "not a git repository \u2014 worktree/isolated modes will fail. Run: git init"
-      };
-    }
-  }
-};
-
-export { DoctorService };

package/dist/chunk-LV6GDBBI.js

@@ -1,297 +0,0 @@
-#!/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

@@ -1,69 +0,0 @@
-#!/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 };