claude-task-worker 0.4.0 → 0.6.0

package/dist/index.js

@@ -231,7 +231,7 @@ var DEFAULT_WORKER_CONFIG = {
 var WORKER_DEFAULTS = {
   "answer-issue-questions": {
     skill: "/claude-task-worker:answer-issue-questions",
-    model: "sonnet",
+    model: "opus",
     effort: "xhigh",
     pollingIntervalSeconds: 60,
     cooldownSeconds: 0,
@@ -505,6 +505,14 @@ function isRunning(id) {
   const task = tasks.get(id);
   return task?.status === "running";
 }
+function isWorktreeInUse(worktreeId) {
+  for (const task of tasks.values()) {
+    if (task.status === "running" && task.path === worktreeId) {
+      return true;
+    }
+  }
+  return false;
+}
 function isWorkerAtCapacity(workerName) {
   let count = 0;
   for (const task of tasks.values()) {
@@ -951,6 +959,9 @@ function generateWorktreeName() {
   const suffix = String(randomInt(1e4)).padStart(4, "0");
   return `${pick(ADJECTIVES)}-${pick(NOUNS)}-${suffix}`;
 }
+function isGeneratedWorktreeName(name) {
+  return /^[a-z]+-[a-z]+-\d{4}$/.test(name);
+}
 
 // src/slack.ts
 import { exec } from "node:child_process";
@@ -1087,69 +1098,152 @@ async function notifyError(workerName, repoName, error) {
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 import { readdir, rm, stat } from "node:fs/promises";
-import { resolve, sep } from "node:path";
+import { basename, resolve, sep } from "node:path";
 var execFileAsync2 = promisify3(execFile3);
 var WORKTREES_DIR = ".claude/worktrees";
 function isManagedWorktreePath(path) {
   return resolve(path).startsWith(resolve(WORKTREES_DIR) + sep);
 }
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function forceRemoveIfExists(path) {
   if (!isManagedWorktreePath(path)) {
     console.error(`[worktree] Refusing to remove path outside ${WORKTREES_DIR}: ${path}`);
     return;
   }
+  if (!await pathExists(path)) return;
   try {
-    await stat(path);
+    await rm(path, { recursive: true, force: true });
+    console.log(`[worktree] Force removed remaining directory: ${path}`);
+  } catch (error) {
+    console.error(`[worktree] Failed to remove directory ${path}:`, error);
+  }
+}
+async function listWorktreeEntries() {
+  const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"]);
+  return stdout.replace(/\r\n/g, "\n").trim().split("\n\n").filter(Boolean).map((entry) => {
+    const lines = entry.split("\n");
+    const worktreeLine = lines.find((l) => l.startsWith("worktree "));
+    const branchLine = lines.find((l) => l.startsWith("branch refs/heads/"));
+    return {
+      path: worktreeLine ? worktreeLine.slice("worktree ".length) : "",
+      branch: branchLine?.slice("branch refs/heads/".length),
+      locked: lines.some((l) => l === "locked" || l.startsWith("locked "))
+    };
+  }).filter((e) => e.path !== "");
+}
+async function removeRegisteredWorktree(worktreePath) {
+  try {
+    await execFileAsync2("git", ["worktree", "remove", "--force", "--force", worktreePath]);
+  } catch (error) {
+    console.error(`[worktree] Failed to remove worktree ${worktreePath}:`, error);
+  }
+  await forceRemoveIfExists(worktreePath);
+}
+var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["main", "master", "develop"]);
+async function getDefaultBranchName() {
+  try {
+    const { stdout } = await execFileAsync2("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    return stdout.trim().replace(/^origin\//, "");
   } catch {
+    return void 0;
+  }
+}
+async function deleteLocalBranch(branchName) {
+  const defaultBranch = await getDefaultBranchName();
+  if (PROTECTED_BRANCHES.has(branchName) || branchName === defaultBranch) {
+    console.log(`[worktree] Skipping deletion of protected branch: ${branchName}`);
     return;
   }
-  await rm(path, { recursive: true, force: true });
-  console.log(`[worktree] Force removed remaining directory: ${path}`);
+  try {
+    await execFileAsync2("git", ["branch", "-D", branchName]);
+    console.log(`[worktree] Deleted local branch: ${branchName}`);
+  } catch (error) {
+    const stderr = String(error?.stderr ?? "");
+    if (/not found/i.test(stderr)) return;
+    console.error(`[worktree] Failed to delete local branch ${branchName}: ${stderr.trim()}`);
+  }
 }
 function getWorktreePath(worktreeId) {
   return `${WORKTREES_DIR}/${worktreeId}`;
 }
 async function createWorktreeFromBranch(worktreeId, baseBranch) {
-  const worktreePath = `${WORKTREES_DIR}/${worktreeId}`;
+  const worktreePath = getWorktreePath(worktreeId);
   await execFileAsync2("git", ["worktree", "add", "-B", worktreeId, worktreePath, `origin/${baseBranch}`]);
 }
 async function removeWorktree(worktreeId) {
-  const worktreePath = `${WORKTREES_DIR}/${worktreeId}`;
+  const worktreePath = getWorktreePath(worktreeId);
+  let entry;
   try {
-    await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath]);
+    entry = (await listWorktreeEntries()).find((e) => resolve(e.path) === resolve(worktreePath));
   } catch (error) {
-    console.error(`[worktree] Failed to remove worktree ${worktreeId}:`, error);
+    console.error(`[worktree] Failed to list worktrees:`, error);
+  }
+  if (entry) {
+    await removeRegisteredWorktree(worktreePath);
+  } else {
+    await forceRemoveIfExists(worktreePath);
+  }
+  const branches = /* @__PURE__ */ new Set([entry?.branch, worktreeId]);
+  for (const branch of branches) {
+    if (!branch) continue;
+    await deleteLocalBranch(branch);
   }
-  await forceRemoveIfExists(worktreePath);
 }
 async function removeWorktreeByBranch(branchName) {
   try {
-    const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"]);
-    const entries = stdout.trim().split("\n\n").filter(Boolean);
+    const entries = await listWorktreeEntries();
     for (const entry of entries) {
-      const branchLine = entry.split("\n").find((l) => l.startsWith("branch "));
-      if (!branchLine) continue;
-      const branch = branchLine.replace("branch refs/heads/", "");
-      if (branch !== branchName) continue;
-      const worktreeLine = entry.split("\n").find((l) => l.startsWith("worktree "));
-      if (!worktreeLine) continue;
-      const worktreePath = worktreeLine.replace("worktree ", "");
-      if (!isManagedWorktreePath(worktreePath)) {
-        console.log(`[worktree] Skipping unmanaged worktree for branch ${branchName}: ${worktreePath}`);
+      if (entry.branch !== branchName) continue;
+      if (!isManagedWorktreePath(entry.path)) {
+        console.log(`[worktree] Skipping unmanaged worktree for branch ${branchName}: ${entry.path}`);
         continue;
       }
-      try {
-        await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath]);
-        console.log(`[worktree] Removed worktree for branch ${branchName}: ${worktreePath}`);
-      } catch (error) {
-        console.error(`[worktree] Failed to remove worktree for branch ${branchName}:`, error);
+      const worktreeId = basename(entry.path);
+      if (isWorktreeInUse(worktreeId)) {
+        console.log(`[worktree] Skipping worktree in use by a running task for branch ${branchName}: ${entry.path}`);
+        continue;
+      }
+      if (entry.locked && await pathExists(entry.path)) {
+        console.log(`[worktree] Skipping locked worktree for branch ${branchName}: ${entry.path}`);
+        continue;
       }
-      await forceRemoveIfExists(worktreePath);
+      await removeRegisteredWorktree(entry.path);
+      console.log(`[worktree] Removed worktree for branch ${branchName}: ${entry.path}`);
     }
   } catch (error) {
     console.error(`[worktree] Failed to remove worktree for branch ${branchName}:`, error);
   }
 }
+async function removeStaleWorktrees() {
+  const worktreeIds = /* @__PURE__ */ new Set();
+  try {
+    for (const name of await readdir(WORKTREES_DIR)) {
+      if (isGeneratedWorktreeName(name)) worktreeIds.add(name);
+    }
+  } catch {
+  }
+  try {
+    for (const entry of await listWorktreeEntries()) {
+      if (!isManagedWorktreePath(entry.path)) continue;
+      const worktreeId = basename(entry.path);
+      if (isGeneratedWorktreeName(worktreeId)) worktreeIds.add(worktreeId);
+    }
+  } catch (error) {
+    console.error(`[worktree] Failed to list worktrees:`, error);
+  }
+  for (const worktreeId of worktreeIds) {
+    if (isWorktreeInUse(worktreeId)) continue;
+    console.log(`[worktree] Removing stale worktree: ${worktreeId}`);
+    await removeWorktree(worktreeId);
+  }
+}
 
 // src/workers/issue-worker.ts
 var LABEL_TRIAGE_SCOPE = "cc-triage-scope";
@@ -1194,7 +1288,6 @@ function createIssuePollingWorker(config) {
             const { model, effort, skill } = getWorkerConfig(config.name);
             const command = skill || config.command;
             const parentNumber = issue.parent?.number;
-            let cwd;
             const claudeArgs = [
               "-p",
               `${command} ${issue.number}`,
@@ -1204,17 +1297,14 @@ function createIssuePollingWorker(config) {
               "--effort",
               effort
             ];
+            let baseBranch = defaultBranch;
             if (parentNumber !== void 0) {
-              const epicBranch = `cc-epic-${parentNumber}`;
-              await ensureEpicBranch(epicBranch, defaultBranch);
-              await createWorktreeFromBranch(worktreeId, epicBranch);
-              cwd = getWorktreePath(worktreeId);
-              console.log(
-                `[${config.name}] #${issue.number}: created worktree ${worktreeId} from ${epicBranch} (parent #${parentNumber})`
-              );
-            } else {
-              claudeArgs.push("--worktree", worktreeId);
+              baseBranch = `cc-epic-${parentNumber}`;
+              await ensureEpicBranch(baseBranch, defaultBranch);
             }
+            await createWorktreeFromBranch(worktreeId, baseBranch);
+            const cwd = getWorktreePath(worktreeId);
+            console.log(`[${config.name}] #${issue.number}: created worktree ${worktreeId} from ${baseBranch}`);
             run(
               "claude",
               claudeArgs,
@@ -1313,25 +1403,18 @@ function createPrPollingWorker(config) {
           const prUrl = `https://github.com/${owner}/${name}/pull/${pr.number}`;
           const hadTriageScope = pr.labels.some((l) => l.name === LABEL_TRIAGE_SCOPE2);
           await addLabel("pr", pr.number, LABEL_IN_PROGRESS);
+          const worktreeId = generateWorktreeName();
           try {
             await removeWorktreeByBranch(pr.headRefName);
-            const worktreeId = generateWorktreeName();
+            await deleteLocalBranch(pr.headRefName);
             syncDefaultBranch(defaultBranch);
+            await createWorktreeFromBranch(worktreeId, defaultBranch);
+            const cwd = getWorktreePath(worktreeId);
             const { model, effort, skill } = getWorkerConfig(config.name);
             const command = skill || config.command;
             run(
               "claude",
-              [
-                "-p",
-                `${command} ${pr.number}`,
-                "--dangerously-skip-permissions",
-                "--model",
-                model,
-                "--effort",
-                effort,
-                "--worktree",
-                worktreeId
-              ],
+              ["-p", `${command} ${pr.number}`, "--dangerously-skip-permissions", "--model", model, "--effort", effort],
               pr.number,
               `PR #${pr.number} (${pr.headRefName})`,
               config.name,
@@ -1372,12 +1455,15 @@ function createPrPollingWorker(config) {
                     (err) => console.error(`[${config.name}] removeWorktree failed for PR #${pr.number}: ${err}`)
                   );
                 }
-              }
+              },
+              cwd
             );
           } catch (err) {
             console.error(`[${config.name}] setup error for PR #${pr.number}: ${err}`);
             await removeLabel("pr", pr.number, LABEL_IN_PROGRESS).catch(() => {
             });
+            await removeWorktree(worktreeId).catch(() => {
+            });
             await notifyError(config.name, name, err);
           }
         }
@@ -1902,19 +1988,23 @@ if (workerType === "init") {
 } else if (workerType === "all") {
   const epicFilters = parseEpicFilters();
   const labelFilters = parseLabelFilters();
-  Promise.all([
-    execIssueWorker({ epicFilters, labelFilters }),
-    fixReviewPointWorker(),
-    createIssueWorker({ epicFilters, labelFilters }),
-    updateIssueWorker({ epicFilters, labelFilters }),
-    answerIssueQuestionsWorker({ epicFilters, labelFilters }),
-    resolveConflictWorker(),
-    epicIssueWorker({ epicFilters, labelFilters })
-  ]);
+  (async () => {
+    await removeStaleWorktrees();
+    await Promise.all([
+      execIssueWorker({ epicFilters, labelFilters }),
+      fixReviewPointWorker(),
+      createIssueWorker({ epicFilters, labelFilters }),
+      updateIssueWorker({ epicFilters, labelFilters }),
+      answerIssueQuestionsWorker({ epicFilters, labelFilters }),
+      resolveConflictWorker(),
+      epicIssueWorker({ epicFilters, labelFilters })
+    ]);
+  })();
 } else if (workerType === "yolo") {
   const epicFilters = parseEpicFilters();
   const labelFilters = parseLabelFilters();
   (async () => {
+    await removeStaleWorktrees();
     await Promise.all([
       execIssueWorker({ epicFilters, labelFilters }),
       fixReviewPointWorker(),
@@ -1931,5 +2021,8 @@ if (workerType === "init") {
 } else {
   const epicFilters = parseEpicFilters();
   const labelFilters = parseLabelFilters();
-  WORKERS[workerType]({ epicFilters, labelFilters });
+  (async () => {
+    await removeStaleWorktrees();
+    await WORKERS[workerType]({ epicFilters, labelFilters });
+  })();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-task-worker",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "CLI tool that polls GitHub Issues/PRs and delegates work to Claude CLI",
   "type": "module",
   "main": "dist/index.js",