claude-task-worker 0.27.1 → 0.29.0

package/README.md

@@ -312,7 +312,7 @@ claude-task-worker exec-issue --project app-a --epic 100 --label priority-high
 
 `mode: "herdr"` のときの1タスクの流れ:
 
-1. worktree を作成し、`ctw:<プロジェクト名>:#<Issue/PR番号>` ラベルのタブで claude を TUI 起動する（`HERDR_DISABLE_SOUND=1` を設定するため通知音は鳴らない）
+1. worktree を作成し、`ctw:<プロジェクト名>:#<Issue/PR番号>` ラベルのタブで claude を TUI 起動する
 2. herdr が持つ agent ステータスを監視し、`working` → `idle` の遷移をタスク完了とみなす
 3. 完了したらペインの内容を回収して通知に使い、タブを閉じてラベル・worktree を後片付けする
 
@@ -321,6 +321,15 @@ claude-task-worker exec-issue --project app-a --epic 100 --label priority-high
 - タブは `--project` で起動した場合そのプロジェクトのワークスペース内に作られる（herdrが各ペインへ注入する `HERDR_WORKSPACE_ID` を利用する）
 - `blocked`（claudeが入力待ち）になってもタスクは自動失敗にせず待機し続ける。ステータステーブルに `running:blocked` と表示されるので、herdrのタブを開いて直接対応できる
 - `mode: "herdr"` でherdrが未インストール・未起動の場合、ワーカーは起動時にエラー終了する（`"default"` へ勝手にフォールバックしない）
+- **タスク完了時の通知音はワーカー側から止められない**。herdr のエージェント状態遷移音を再生するのは herdr サーバープロセスで、`HERDR_DISABLE_SOUND` もそのプロセスの環境変数として読まれるため、タスクペインへ渡しても効かない（socket API にもペイン単位のミュートは無い）。無音にしたい場合は herdr 側の設定で行う:
+
+  ```toml
+  # ~/.config/herdr/config.toml
+  [ui.sound]
+  enabled = false
+  ```
+
+  適用は `herdr server reload-config`。この設定は herdr サーバー全体に効くため、ワーカー以外の対話セッションの完了音も鳴らなくなる（`[ui.sound.agents] claude = "off"` でも実質同じ範囲）。ワーカーだけを無音にしたい場合は、`HERDR_DISABLE_SOUND=1 herdr --session <name>` で別セッションを起動し、その中でディスパッチャーを動かす
 
 ### exec-issue
 

package/dist/index.js

@@ -75,6 +75,7 @@ __export(herdr_exports, {
   tabRename: () => tabRename,
   workspaceClose: () => workspaceClose,
   workspaceCreate: () => workspaceCreate,
+  workspaceFocus: () => workspaceFocus,
   workspaceList: () => workspaceList
 });
 import { createRequire as createRequire2 } from "node:module";
@@ -210,12 +211,16 @@ async function workspaceList() {
   }
   return result.workspaces.map((workspace) => ({
     workspaceId: workspace.workspace_id,
-    label: workspace.label ?? ""
+    label: workspace.label ?? "",
+    focused: workspace.focused === true
   }));
 }
 async function workspaceClose(workspaceId) {
   await execHerdr(["workspace", "close", workspaceId]);
 }
+async function workspaceFocus(workspaceId) {
+  await execHerdr(["workspace", "focus", workspaceId]);
+}
 async function agentStart({
   name,
   cwd,
@@ -529,6 +534,49 @@ var init_herdr_runner = __esm({
   }
 });
 
+// src/commands/run-command.ts
+var run_command_exports = {};
+__export(run_command_exports, {
+  runCommand: () => runCommand
+});
+import { spawn as spawn2 } from "node:child_process";
+function runCommand(command, args) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn2(command, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    const forwardSignal = (signal) => {
+      child.kill(signal);
+    };
+    const onSigint = () => forwardSignal("SIGINT");
+    const onSigterm = () => forwardSignal("SIGTERM");
+    const cleanup = () => {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGTERM", onSigterm);
+    };
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    child.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+    child.on("close", (code) => {
+      cleanup();
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+      }
+    });
+  });
+}
+var init_run_command = __esm({
+  "src/commands/run-command.ts"() {
+    "use strict";
+  }
+});
+
 // src/dispatcher.ts
 var dispatcher_exports = {};
 __export(dispatcher_exports, {
@@ -542,6 +590,7 @@ __export(dispatcher_exports, {
   WORKER_STARTUP_POLL_INTERVAL_MS: () => WORKER_STARTUP_POLL_INTERVAL_MS,
   WORKER_STARTUP_TIMEOUT_MS: () => WORKER_STARTUP_TIMEOUT_MS,
   createDispatcherShutdownHandler: () => createDispatcherShutdownHandler,
+  focusedWorkspaceId: () => focusedWorkspaceId,
   formatUptime: () => formatUptime,
   isShellProcess: () => isShellProcess,
   isWorkerProcess: () => isWorkerProcess,
@@ -549,6 +598,7 @@ __export(dispatcher_exports, {
   pollOnce: () => pollOnce,
   removeSession: () => removeSession,
   renderSessionTable: () => renderSessionTable,
+  restoreWorkspaceFocus: () => restoreWorkspaceFocus,
   runDispatcher: () => runDispatcher,
   shutdownDispatcher: () => shutdownDispatcher,
   startWorkerInPane: () => startWorkerInPane,
@@ -565,6 +615,25 @@ async function loadTable() {
 function workspaceLabelFor(projectName) {
   return `${LABEL_PREFIX}${projectName}`;
 }
+async function focusedWorkspaceId(herdr) {
+  try {
+    const workspaces = await herdr.workspaceList();
+    return workspaces.find((workspace) => workspace.focused)?.workspaceId;
+  } catch (error) {
+    console.error(`[dispatcher] failed to read the focused workspace: ${error}`);
+    return void 0;
+  }
+}
+async function restoreWorkspaceFocus(herdr, previousWorkspaceId, closingWorkspaceIds) {
+  if (!previousWorkspaceId || closingWorkspaceIds.has(previousWorkspaceId)) return;
+  const currentWorkspaceId = await focusedWorkspaceId(herdr);
+  if (currentWorkspaceId === previousWorkspaceId) return;
+  try {
+    await herdr.workspaceFocus(previousWorkspaceId);
+  } catch (error) {
+    console.error(`[dispatcher] failed to restore focus to workspace "${previousWorkspaceId}": ${error}`);
+  }
+}
 function sleep2(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
@@ -676,23 +745,27 @@ async function runDispatcher(projects, forwardedCommand, timing) {
       console.error(`[dispatcher] failed to dispatch project "${project.name}": ${error}`);
       sessions.delete(project.name);
       if (createdWorkspaceId !== void 0) {
+        const focusedBefore = await focusedWorkspaceId(herdr);
         try {
           await workspaceClose2(createdWorkspaceId);
         } catch (closeError) {
           console.error(`[dispatcher] failed to close dangling workspace for project "${project.name}": ${closeError}`);
         }
+        await restoreWorkspaceFocus(herdr, focusedBefore, /* @__PURE__ */ new Set([createdWorkspaceId]));
       }
     }
   }
   return sessions;
 }
-async function removeSession(sessions, name, { closeWorkspace }) {
+async function removeSession(sessions, name, { closeWorkspace }, herdrModule) {
   const session = sessions.get(name);
   if (!session) return;
   sessions.delete(name);
   if (closeWorkspace) {
-    const { workspaceClose: workspaceClose2 } = await loadHerdr2();
-    await workspaceClose2(session.workspaceId);
+    const herdr = herdrModule ?? await loadHerdr2();
+    const focusedBefore = await focusedWorkspaceId(herdr);
+    await herdr.workspaceClose(session.workspaceId);
+    await restoreWorkspaceFocus(herdr, focusedBefore, /* @__PURE__ */ new Set([session.workspaceId]));
   }
 }
 async function pollOnce(sessions, herdr) {
@@ -700,11 +773,11 @@ async function pollOnce(sessions, herdr) {
     try {
       const { foregroundProcesses } = await herdr.paneProcessInfo(session.paneId);
       if (!foregroundProcesses.some(isWorkerProcess)) {
-        await removeSession(sessions, name, { closeWorkspace: true });
+        await removeSession(sessions, name, { closeWorkspace: true }, herdr);
       }
     } catch (error) {
       if (error instanceof herdr.HerdrError && error.code === "pane_not_found") {
-        await removeSession(sessions, name, { closeWorkspace: false });
+        await removeSession(sessions, name, { closeWorkspace: false }, herdr);
         continue;
       }
       console.error(`[dispatcher] failed to poll session "${name}": ${error}`);
@@ -802,6 +875,8 @@ async function waitUntilSessionsEmpty(sessions, herdr, pollIntervalMs, timeoutMs
   return true;
 }
 async function closeRemainingWorkspaces(sessions, herdr, timeoutMs) {
+  const closingWorkspaceIds = new Set([...sessions.values()].map((session) => session.workspaceId));
+  const focusedBefore = await focusedWorkspaceId(herdr);
   const results = await Promise.all(
     [...sessions.values()].map(async (session) => {
       try {
@@ -820,6 +895,7 @@ async function closeRemainingWorkspaces(sessions, herdr, timeoutMs) {
       }
     })
   );
+  await restoreWorkspaceFocus(herdr, focusedBefore, closingWorkspaceIds);
   return results.every((closed) => closed);
 }
 async function forceKillAllSessions(sessions, herdr, workspaceCloseTimeoutMs) {
@@ -1230,8 +1306,7 @@ function buildClaudeArgs({ mode, prompt, model, effort }) {
 function buildClaudeEnv(mode) {
   if (mode === "herdr") {
     return {
-      CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: CLAUDE_SPAWN_ENV.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS,
-      HERDR_DISABLE_SOUND: "1"
+      CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: CLAUDE_SPAWN_ENV.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS
     };
   }
   return { ...CLAUDE_SPAWN_ENV };
@@ -2992,7 +3067,85 @@ var epicIssueWorker = (opts = {}) => createIssuePollingWorker({
 })();
 
 // src/commands/init.ts
-import { mkdir, writeFile, access } from "node:fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2, access } from "node:fs/promises";
+
+// src/commands/codegraph.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname2, join as join5 } from "node:path";
+async function loadRunCommand() {
+  return await Promise.resolve().then(() => (init_run_command(), run_command_exports));
+}
+var CODEGRAPH_PACKAGE = "@colbymchenry/codegraph";
+var CODEGRAPH_IGNORE_ENTRY = ".codegraph/";
+function globalGitIgnorePath(env = process.env, home = homedir4()) {
+  const xdg = env.XDG_CONFIG_HOME?.trim();
+  const base = xdg ? xdg : join5(home, ".config");
+  return join5(base, "git", "ignore");
+}
+function appendIgnoreEntry(current, entry) {
+  const bare = entry.replace(/\/$/, "");
+  const alreadyListed = current.split("\n").map((line) => line.trim()).some((line) => line === entry || line === bare);
+  if (alreadyListed) return null;
+  if (current === "") return `${entry}
+`;
+  return current.endsWith("\n") ? `${current}${entry}
+` : `${current}
+${entry}
+`;
+}
+async function installCodegraphCli(logPrefix, mode) {
+  const progressive = mode === "install" ? "Installing" : "Updating";
+  const past = mode === "install" ? "installed" : "updated";
+  console.log(`[${logPrefix}] ${progressive} CodeGraph CLI (npm install -g ${CODEGRAPH_PACKAGE}@latest)...`);
+  try {
+    const { runCommand: runCommand2 } = await loadRunCommand();
+    await runCommand2("npm", ["install", "-g", `${CODEGRAPH_PACKAGE}@latest`]);
+    console.log(`[${logPrefix}] CodeGraph CLI ${past}.`);
+    return true;
+  } catch (err) {
+    console.error(`[${logPrefix}] Failed to ${mode} CodeGraph CLI: ${err.message}`);
+    return false;
+  }
+}
+async function runCodegraphInit(logPrefix) {
+  console.log(`[${logPrefix}] Initializing CodeGraph index (codegraph init)...`);
+  try {
+    const { runCommand: runCommand2 } = await loadRunCommand();
+    await runCommand2("codegraph", ["init"]);
+    console.log(`[${logPrefix}] CodeGraph index initialized.`);
+    return true;
+  } catch (err) {
+    console.error(
+      `[${logPrefix}] Failed to run codegraph init (install it with \`claude-task-worker install\`): ${err.message}`
+    );
+    return false;
+  }
+}
+async function ensureCodegraphGitIgnore(logPrefix) {
+  const path = globalGitIgnorePath();
+  try {
+    let current = "";
+    try {
+      current = await readFile(path, "utf-8");
+    } catch {
+    }
+    const next = appendIgnoreEntry(current, CODEGRAPH_IGNORE_ENTRY);
+    if (next === null) {
+      console.log(`[${logPrefix}] Already ignored: ${CODEGRAPH_IGNORE_ENTRY} (${path})`);
+      return true;
+    }
+    await mkdir(dirname2(path), { recursive: true });
+    await writeFile(path, next, "utf-8");
+    console.log(`[${logPrefix}] Added ${CODEGRAPH_IGNORE_ENTRY} to ${path}`);
+    return true;
+  } catch (err) {
+    console.error(`[${logPrefix}] Failed to update ${path}: ${err.message}`);
+    return false;
+  }
+}
+
+// src/commands/init.ts
 var LABELS = [
   { name: "cc-update-issue", color: "e4e669" },
   { name: "cc-answer-issue-questions", color: "5319e7" },
@@ -3048,10 +3201,10 @@ async function writeFileWithMode(path, content, force) {
   try {
     await access(path);
     if (!force) return "skipped";
-    await writeFile(path, content, "utf-8");
+    await writeFile2(path, content, "utf-8");
     return "overwritten";
   } catch {
-    await writeFile(path, content, "utf-8");
+    await writeFile2(path, content, "utf-8");
     return "created";
   }
 }
@@ -3077,53 +3230,23 @@ async function init(options = {}) {
     }
   }
   console.log("[init] Creating issue template...");
-  await mkdir(".github/ISSUE_TEMPLATE", { recursive: true });
+  await mkdir2(".github/ISSUE_TEMPLATE", { recursive: true });
   const templatePath = ".github/ISSUE_TEMPLATE/cc-triage-scope.yml";
   logWriteResult(await writeFileWithMode(templatePath, ISSUE_TEMPLATE, force), templatePath);
   console.log("[init] Creating GitHub Actions workflow...");
-  await mkdir(".github/workflows", { recursive: true });
+  await mkdir2(".github/workflows", { recursive: true });
   const workflowPath = ".github/workflows/assign-creator-on-cc-triage-scope.yml";
   logWriteResult(await writeFileWithMode(workflowPath, ASSIGN_CREATOR_WORKFLOW, force), workflowPath);
   console.log("[init] Creating config file...");
   await createConfig(force);
+  console.log("[init] Setting up CodeGraph...");
+  await ensureCodegraphGitIgnore("init");
+  await runCodegraphInit("init");
   console.log("[init] Done.");
 }
 
-// src/commands/run-command.ts
-import { spawn as spawn2 } from "node:child_process";
-function runCommand(command, args) {
-  return new Promise((resolve3, reject) => {
-    const child = spawn2(command, args, {
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    const forwardSignal = (signal) => {
-      child.kill(signal);
-    };
-    const onSigint = () => forwardSignal("SIGINT");
-    const onSigterm = () => forwardSignal("SIGTERM");
-    const cleanup = () => {
-      process.removeListener("SIGINT", onSigint);
-      process.removeListener("SIGTERM", onSigterm);
-    };
-    process.once("SIGINT", onSigint);
-    process.once("SIGTERM", onSigterm);
-    child.on("error", (err) => {
-      cleanup();
-      reject(err);
-    });
-    child.on("close", (code) => {
-      cleanup();
-      if (code === 0) {
-        resolve3();
-      } else {
-        reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
-      }
-    });
-  });
-}
-
 // src/commands/install.ts
+init_run_command();
 var PLUGIN_NAME = "claude-task-worker";
 var MARKETPLACE_NAME = "claude-task-worker";
 var MARKETPLACE_SOURCE = "getty104/claude-task-worker";
@@ -3165,13 +3288,15 @@ async function install() {
   await addMarketplace();
   const pluginOk = await installPlugin();
   const cliOk = await installCli();
-  if (!pluginOk || !cliOk) {
+  const codegraphOk = await installCodegraphCli("install", "install");
+  if (!pluginOk || !cliOk || !codegraphOk) {
     process.exitCode = 1;
   }
   console.log("[install] Done.");
 }
 
 // src/commands/update.ts
+init_run_command();
 var PLUGIN_NAME2 = "claude-task-worker";
 var MARKETPLACE_NAME2 = "claude-task-worker";
 async function updateMarketplace() {
@@ -3212,7 +3337,8 @@ async function update() {
   const marketplaceOk = await updateMarketplace();
   const pluginOk = await updatePlugin();
   const cliOk = await updateCli();
-  if (!marketplaceOk || !pluginOk || !cliOk) {
+  const codegraphOk = await installCodegraphCli("update", "update");
+  if (!marketplaceOk || !pluginOk || !cliOk || !codegraphOk) {
     process.exitCode = 1;
   }
   console.log("[update] Done.");
@@ -3220,11 +3346,11 @@ async function update() {
 
 // src/commands/version.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { dirname as dirname3, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 function version() {
-  const here = dirname2(fileURLToPath(import.meta.url));
-  const pkgPath = join5(here, "..", "package.json");
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const pkgPath = join6(here, "..", "package.json");
   try {
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     console.log(pkg.version ?? "unknown");

package/package.json

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