@oxgeneral/orch 1.0.1 → 1.0.3

package/dist/tui-LN5XHSQY.js

@@ -1,245 +0,0 @@
-#!/usr/bin/env node
-// src/cli/commands/tui.ts
-function registerTuiCommand(program, container) {
-  program.command("tui").description("Launch interactive TUI dashboard").action(async () => {
-    await container.paths.requireInit();
-    const tasks = await container.taskService.list();
-    const agents = await container.agentService.list();
-    const state = await container.stateStore.read();
-    const { render } = await import('ink');
-    const { createElement } = await import('react');
-    const { App } = await import('./App-GJVTVGRU.js');
-    const onRunTask = async (taskId) => {
-      await container.orchestrator.runTask(taskId);
-    };
-    const onCreateTask = async (title, opts) => {
-      return container.taskService.create({
-        title,
-        priority: opts?.priority,
-        description: opts?.description,
-        attachments: opts?.attachments
-      });
-    };
-    const onCancelTask = async (taskId) => {
-      await container.orchestrator.cancelTask(taskId);
-    };
-    const onRetryTask = async (taskId) => {
-      await container.taskService.retry(taskId);
-    };
-    const onAssignTask = async (taskId, agentId) => {
-      await container.taskService.assign(taskId, agentId);
-    };
-    const onRunAll = async () => {
-      await container.orchestrator.runAll();
-    };
-    const onDisableAgent = async (agentId) => {
-      await container.agentService.disable(agentId);
-    };
-    const onEnableAgent = async (agentId) => {
-      await container.agentService.enable(agentId);
-    };
-    const onSubscribeEvents = (handler) => {
-      return container.eventBus.onAny(handler);
-    };
-    const onRefreshTasks = async () => {
-      return container.taskService.list();
-    };
-    const onRefreshAgents = async () => {
-      return container.agentService.list();
-    };
-    const onRefreshState = async () => {
-      return container.stateStore.read();
-    };
-    const onAddAgent = async (name, adapter, opts) => {
-      return container.agentService.create({
-        name,
-        adapter: adapter ?? "claude",
-        model: opts?.model || void 0,
-        role: opts?.role || void 0,
-        approval_policy: opts?.approval_policy || void 0,
-        skills: opts?.skills || void 0
-      });
-    };
-    const onDeleteAgent = async (agentId) => {
-      await container.agentService.remove(agentId);
-    };
-    const onDeleteTask = async (taskId) => {
-      await container.taskService.delete(taskId);
-    };
-    const onApproveTask = async (taskId) => {
-      await container.taskService.updateStatus(taskId, "done");
-    };
-    const onRejectTask = async (taskId, feedback) => {
-      await container.taskService.reject(taskId, feedback);
-    };
-    const onUpdateTask = async (taskId, fields) => {
-      return container.taskService.update(taskId, fields);
-    };
-    const onUpdateAgent = async (agentId, fields) => {
-      return container.agentService.update(agentId, {
-        ...fields,
-        approval_policy: fields.approval_policy
-      });
-    };
-    const onForceStopAgent = async (agentId) => {
-      await container.orchestrator.forceStopAgent(agentId);
-    };
-    const onToggleAutonomous = async (agentId, enabled) => {
-      return container.agentService.setAutonomous(agentId, enabled);
-    };
-    const onLoadHistory = async (onBatch) => {
-      const allRuns = await container.runService.listAll();
-      const FIRST_BATCH = 3;
-      const TOTAL_RUNS = 10;
-      const firstRuns = allRuns.slice(0, FIRST_BATCH);
-      const restRuns = allRuns.slice(FIRST_BATCH, TOTAL_RUNS);
-      const loadRunEvents = async (run) => {
-        const events = await container.runService.readEventsTail(run.id, 30);
-        return events.map((evt) => ({
-          timestamp: evt.timestamp,
-          agentId: run.agent_id,
-          taskId: run.task_id,
-          type: evt.type,
-          data: evt.data
-        }));
-      };
-      if (firstRuns.length > 0) {
-        const firstEntries = (await Promise.all(firstRuns.map(loadRunEvents))).flat();
-        firstEntries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        onBatch(firstEntries.slice(-200));
-      }
-      if (restRuns.length > 0) {
-        const restEntries = (await Promise.all(restRuns.map(loadRunEvents))).flat();
-        restEntries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        onBatch(restEntries.slice(-200));
-      }
-    };
-    const onCreateTeam = async (input) => {
-      return container.teamService.create(input);
-    };
-    const onListTeams = async () => {
-      return container.teamService.list();
-    };
-    const onJoinTeam = async (teamId, agentId) => {
-      return container.teamService.join(teamId, agentId);
-    };
-    const onLeaveTeam = async (teamId, agentId) => {
-      return container.teamService.leave(teamId, agentId);
-    };
-    const onDisbandTeam = async (teamId) => {
-      await container.teamService.disband(teamId);
-    };
-    const onSetTeamLead = async (teamId, agentId) => {
-      return container.teamService.setLead(teamId, agentId);
-    };
-    const onRefreshGoals = async () => {
-      return container.goalService.list();
-    };
-    const onCreateGoal = async (input) => {
-      return container.goalService.create(input);
-    };
-    const onUpdateGoal = async (id, fields) => {
-      return container.goalService.update(id, fields);
-    };
-    const onUpdateGoalStatus = async (id, status) => {
-      return container.goalService.updateStatus(id, status);
-    };
-    const onDeleteGoal = async (id) => {
-      await container.goalService.delete(id);
-    };
-    const onGetGoalProgress = async (goalId) => {
-      return container.goalService.getProgressReport(goalId);
-    };
-    const onStartWatch = async () => {
-      await container.orchestrator.startWatch();
-    };
-    const onStopWatch = async () => {
-      await container.orchestrator.stop();
-    };
-    const currentVersion = program.version() ?? "0.0.0";
-    const updateCheckPromise = import('./update-check-4YKLGBFB.js').then((m) => m.checkForUpdateSWR(currentVersion)).catch(() => null);
-    let watchStarted = false;
-    let watchError;
-    try {
-      await container.orchestrator.startWatch();
-      watchStarted = true;
-    } catch (err) {
-      watchError = err instanceof Error ? err.message : String(err);
-    }
-    const updateInfo = await updateCheckPromise;
-    const { waitUntilExit } = render(
-      createElement(App, {
-        projectName: container.config.project.name,
-        tasks,
-        agents,
-        state,
-        onRunTask,
-        onCreateTask,
-        onCancelTask,
-        onRetryTask,
-        onAssignTask,
-        onRunAll,
-        onDisableAgent,
-        onEnableAgent,
-        onSubscribeEvents,
-        onRefreshTasks,
-        onRefreshAgents,
-        onRefreshState,
-        onLoadHistory,
-        onAddAgent,
-        onDeleteAgent,
-        onApproveTask,
-        onRejectTask,
-        onDeleteTask,
-        onUpdateTask,
-        onUpdateAgent,
-        onForceStopAgent,
-        onToggleAutonomous,
-        onRefreshGoals,
-        onCreateGoal,
-        onUpdateGoal,
-        onUpdateGoalStatus,
-        onDeleteGoal,
-        onGetGoalProgress,
-        onCreateTeam,
-        onListTeams,
-        onJoinTeam,
-        onLeaveTeam,
-        onDisbandTeam,
-        onSetTeamLead,
-        onStartWatch,
-        onStopWatch,
-        initialWatchActive: watchStarted,
-        watchError,
-        version: currentVersion,
-        latestVersion: updateInfo?.updateAvailable ? updateInfo.latest : void 0,
-        initialActivityFilter: container.globalConfig.tui.activity_filter,
-        onSaveActivityFilter: async (preset) => {
-          await container.globalConfigStore.set("activity_filter", preset);
-        },
-        initialNotifications: container.globalConfig.tui.notifications,
-        onSaveNotifications: async (notif) => {
-          await container.globalConfigStore.set("notifications", notif);
-        },
-        initialMaxConcurrent: container.config.scheduling.max_concurrent_agents,
-        onSaveMaxConcurrent: async (value) => {
-          await container.configStore.set("scheduling.max_concurrent_agents", value);
-          container.config.scheduling.max_concurrent_agents = value;
-        },
-        onCompleteOnboarding: async () => {
-          const s = await container.stateStore.read();
-          s.onboardingCompleted = true;
-          await container.stateStore.write(s);
-        }
-      }),
-      { kittyKeyboard: { mode: "auto", flags: ["disambiguateEscapeCodes"] } }
-    );
-    await waitUntilExit();
-    if (watchStarted) {
-      await container.orchestrator.stop().catch(() => {
-      });
-    }
-  });
-}
-
-export { registerTuiCommand };

package/dist/update-YLP7FPNY.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-import { checkForUpdateNow } from './chunk-FRTKB575.js';
-import { amber, dim } from './chunk-7X2GI5OV.js';
-import { execFile } from 'child_process';
-import chalk from 'chalk';
-
-var PACKAGE_NAME = "@oxgeneral/orch";
-function runInstall() {
-  return new Promise((resolve) => {
-    const child = execFile(
-      "npm",
-      ["install", "-g", `${PACKAGE_NAME}@latest`],
-      { timeout: 6e4 },
-      (err, stdout, stderr) => {
-        const output = (stdout ?? "") + (stderr ?? "");
-        resolve({ code: err ? 1 : 0, output });
-      }
-    );
-    child.stdout?.pipe(process.stdout);
-    child.stderr?.pipe(process.stderr);
-  });
-}
-function registerUpdateCommand(program) {
-  program.command("update").description("Check for updates and install the latest version").option("--check", "Only check, do not install").action(async (opts) => {
-    console.log();
-    console.log(`  ${amber("orch update")} \xB7 checking for updates\u2026`);
-    console.log();
-    const currentVersion = program.version() ?? "0.0.0";
-    const info = await checkForUpdateNow(currentVersion);
-    if (!info) {
-      console.log(`  ${chalk.ansi256(167)("\u2715")}  Could not reach npm registry`);
-      console.log(`     Check your network connection and try again.`);
-      console.log();
-      process.exit(1);
-    }
-    if (!info.updateAvailable) {
-      console.log(`  ${chalk.ansi256(72)("\u2713")}  Already up to date ${dim(`(${info.current})`)}`);
-      console.log();
-      return;
-    }
-    console.log(`  ${chalk.ansi256(214)("\u25CF")}  Update available: ${dim(info.current)} \u2192 ${chalk.ansi256(72)(info.latest)}`);
-    console.log();
-    if (opts.check) {
-      console.log(`  Run ${dim("orch update")} to install.`);
-      console.log();
-      return;
-    }
-    console.log(`  Installing ${PACKAGE_NAME}@${info.latest}\u2026`);
-    console.log();
-    const result = await runInstall();
-    if (result.code !== 0) {
-      console.log();
-      console.log(`  ${chalk.ansi256(167)("\u2715")}  Update failed. Try manually:`);
-      console.log(`     npm install -g ${PACKAGE_NAME}@latest`);
-      console.log();
-      process.exit(1);
-    }
-    console.log();
-    console.log(`  ${chalk.ansi256(72)("\u2713")}  Updated to ${info.latest}`);
-    console.log();
-  });
-}
-
-export { registerUpdateCommand };

package/dist/update-check-4YKLGBFB.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export { checkForUpdateNow, checkForUpdateSWR, printUpdateNotification } from './chunk-FRTKB575.js';

package/dist/workspace-manager-JM6U7JOH.js

@@ -1,215 +0,0 @@
-#!/usr/bin/env node
-import { sanitizeId, validateWorkspacePath, ensureDir } from './chunk-LV6GDBBI.js';
-import { WorkspaceError } from './chunk-2C2TFQ7K.js';
-import path from 'path';
-import fs from 'fs/promises';
-
-// src/infrastructure/workspace/merge-strategy.ts
-var MergeStrategy = class {
-  constructor(projectRoot, processManager) {
-    this.projectRoot = projectRoot;
-    this.processManager = processManager;
-  }
-  /**
-   * Merge a branch into the current branch with --no-ff.
-   * On conflict, aborts the merge and returns conflict info.
-   */
-  async mergeBack(branch) {
-    return new Promise((resolve) => {
-      const { process: proc } = this.processManager.spawn(
-        "git",
-        ["merge", "--no-ff", branch, "-m", `Merge ${branch}`],
-        { cwd: this.projectRoot }
-      );
-      let output = "";
-      const maxOutputLen = 2e3;
-      const appendOutput = (chunk) => {
-        if (output.length < maxOutputLen) output += chunk.toString();
-      };
-      proc.stdout?.on("data", appendOutput);
-      proc.stderr?.on("data", appendOutput);
-      proc.on("close", (code) => {
-        if (code === 0) {
-          resolve({ success: true });
-          return;
-        }
-        const trimmedOutput = output.slice(0, 1e3);
-        const isConflict = trimmedOutput.includes("CONFLICT") || trimmedOutput.includes("Merge conflict");
-        if (!isConflict) {
-          resolve({ success: false, conflictInfo: trimmedOutput });
-          return;
-        }
-        try {
-          const { process: abortProc } = this.processManager.spawn(
-            "git",
-            ["merge", "--abort"],
-            { cwd: this.projectRoot }
-          );
-          abortProc.on("close", () => {
-            resolve({ success: false, conflictInfo: trimmedOutput });
-          });
-          abortProc.on("error", () => {
-            resolve({ success: false, conflictInfo: trimmedOutput });
-          });
-        } catch {
-          resolve({ success: false, conflictInfo: trimmedOutput });
-        }
-      });
-      proc.on("error", (err) => {
-        resolve({ success: false, conflictInfo: err.message });
-      });
-    });
-  }
-};
-
-// src/infrastructure/workspace/workspace-manager.ts
-var WorkspaceManager = class {
-  constructor(projectRoot, orchestryDir, processManager) {
-    this.projectRoot = projectRoot;
-    this.orchestryDir = orchestryDir;
-    this.processManager = processManager;
-    this.mergeStrategy = new MergeStrategy(projectRoot, processManager);
-  }
-  mergeStrategy;
-  gitRepoChecked = false;
-  isGitRepo = false;
-  async prepare(task, agent, config) {
-    const mode = this.resolveMode(task, agent, config);
-    if (mode !== "shared") {
-      await this.requireGitRepo(mode);
-    }
-    switch (mode) {
-      case "shared":
-        return { path: this.projectRoot };
-      case "worktree":
-        return this.prepareWorktree(task);
-      case "isolated":
-        return { path: await this.prepareIsolated(task) };
-      default:
-        return { path: this.projectRoot };
-    }
-  }
-  async requireGitRepo(mode) {
-    if (!this.gitRepoChecked) {
-      try {
-        const { process: proc } = this.processManager.spawn(
-          "git",
-          ["rev-parse", "--is-inside-work-tree"],
-          { cwd: this.projectRoot }
-        );
-        const code = await new Promise((resolve) => {
-          proc.on("close", resolve);
-          proc.on("error", () => resolve(1));
-        });
-        this.isGitRepo = code === 0;
-      } catch {
-        this.isGitRepo = false;
-      }
-      if (this.isGitRepo) this.gitRepoChecked = true;
-    }
-    if (!this.isGitRepo) {
-      throw new WorkspaceError(
-        `workspace_mode "${mode}" requires a git repository`,
-        'Run: git init && git add -A && git commit -m "Initial commit"\n         Or set workspace_mode: shared in .orchestry/config.yml'
-      );
-    }
-  }
-  async mergeBack(branch) {
-    return this.mergeStrategy.mergeBack(branch);
-  }
-  async cleanup(taskId) {
-    const workspacePath = path.join(this.orchestryDir, "workspaces", sanitizeId(taskId));
-    try {
-      const { process: proc } = this.processManager.spawn(
-        "git",
-        ["worktree", "remove", "--force", workspacePath],
-        { cwd: this.projectRoot }
-      );
-      await new Promise((resolve) => {
-        proc.on("close", () => resolve());
-        proc.on("error", () => resolve());
-      });
-    } catch {
-    }
-    try {
-      await fs.rm(workspacePath, { recursive: true, force: true });
-    } catch {
-    }
-  }
-  validate(workspacePath, projectRoot) {
-    validateWorkspacePath(workspacePath, projectRoot);
-  }
-  resolveMode(task, agent, config) {
-    return task.workspace_mode ?? agent.config.workspace_mode ?? config.defaults.agent.workspace_mode ?? "worktree";
-  }
-  async prepareWorktree(task) {
-    const workspacePath = path.join(
-      this.orchestryDir,
-      "workspaces",
-      sanitizeId(task.id)
-    );
-    await ensureDir(path.dirname(workspacePath));
-    const titleSlug = sanitizeTitle(task.title) || sanitizeId(task.id);
-    const branchName = `orchestry/${sanitizeId(task.id)}/${titleSlug}`;
-    const { process: proc } = this.processManager.spawn(
-      "git",
-      ["worktree", "add", workspacePath, "-b", branchName],
-      { cwd: this.projectRoot }
-    );
-    await new Promise((resolve, reject) => {
-      proc.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`git worktree add failed with code ${code}`));
-      });
-      proc.on("error", reject);
-    });
-    const worktreeOrchestry = path.join(workspacePath, ".orchestry");
-    await fs.rm(worktreeOrchestry, { recursive: true, force: true }).catch(() => {
-    });
-    return { path: workspacePath, branch: branchName };
-  }
-  async prepareIsolated(task) {
-    const workspacePath = path.join(
-      this.orchestryDir,
-      "workspaces",
-      sanitizeId(task.id)
-    );
-    await ensureDir(path.dirname(workspacePath));
-    try {
-      const { process: proc } = this.processManager.spawn(
-        "git",
-        ["clone", "--local", "--no-hardlinks", ".", workspacePath],
-        { cwd: this.projectRoot }
-      );
-      await new Promise((resolve, reject) => {
-        proc.on("close", (code) => {
-          if (code === 0) resolve();
-          else reject(new Error("git clone failed"));
-        });
-        proc.on("error", reject);
-      });
-    } catch {
-      const excludeFile = path.join(this.orchestryDir, "workspace-exclude");
-      const args = ["-a", `--exclude-from=${excludeFile}`, "./", `${workspacePath}/`];
-      const { process: proc } = this.processManager.spawn("rsync", args, {
-        cwd: this.projectRoot
-      });
-      await new Promise((resolve, reject) => {
-        proc.on("close", (code) => {
-          if (code === 0) resolve();
-          else reject(new Error(`rsync failed with code ${code}`));
-        });
-        proc.on("error", reject);
-      });
-    }
-    const clonedOrchestry = path.join(workspacePath, ".orchestry");
-    await fs.rm(clonedOrchestry, { recursive: true, force: true }).catch(() => {
-    });
-    return workspacePath;
-  }
-};
-function sanitizeTitle(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-}
-
-export { WorkspaceManager };