@oxgeneral/orch 1.0.2 → 1.0.4

package/dist/workspace-manager-ESPU7WOH.js

@@ -1,215 +0,0 @@
-#!/usr/bin/env node
-import { sanitizeId, validateWorkspacePath, ensureDir } from './chunk-ITLJKMTP.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 };