claude-task-worker 0.27.0 → 0.28.0

package/dist/index.js

@@ -65,7 +65,6 @@ __export(herdr_exports, {
   getCurrentWorkspaceId: () => getCurrentWorkspaceId,
   paneClose: () => paneClose,
   paneGet: () => paneGet,
-  paneMoveToNewTab: () => paneMoveToNewTab,
   paneProcessInfo: () => paneProcessInfo,
   paneRead: () => paneRead,
   paneSendKeys: () => paneSendKeys,
@@ -79,6 +78,7 @@ __export(herdr_exports, {
   workspaceList: () => workspaceList
 });
 import { createRequire as createRequire2 } from "node:module";
+import { resolve as resolvePath } from "node:path";
 function runHerdr(args) {
   return new Promise((resolve3) => {
     childProcess2.execFile(
@@ -86,24 +86,30 @@ function runHerdr(args) {
       args,
       { timeout: HERDR_TIMEOUT_MS, killSignal: "SIGKILL" },
       (error, stdout, stderr) => {
-        let parsed;
-        try {
-          parsed = JSON.parse(stdout);
-        } catch {
-          parsed = void 0;
-        }
-        resolve3({ execError: error, parsed, stdout, stderr });
+        const parsed = parseHerdrResponse(stdout);
+        const stderrError = parsed?.error ? void 0 : parseHerdrResponse(stderr)?.error;
+        resolve3({ execError: error, parsed, stderrError, stdout, stderr });
       }
     );
   });
 }
+function parseHerdrResponse(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
 async function execHerdr(args, options) {
-  const { execError, parsed, stdout, stderr } = await runHerdr(args);
+  const { execError, parsed, stderrError, stdout, stderr } = await runHerdr(args);
   const stderrSuffix = stderr.trim() ? `: ${stderr.trim()}` : "";
-  if (parsed?.error) {
+  const errorPayload = parsed?.error ?? stderrError;
+  if (errorPayload) {
     throw new HerdrError(
-      `herdr ${args.join(" ")} failed: [${parsed.error.code}] ${parsed.error.message}`,
-      parsed.error.code
+      `herdr ${args.join(" ")} failed: [${errorPayload.code}] ${errorPayload.message}`,
+      errorPayload.code
     );
   }
   if (execError) {
@@ -121,6 +127,9 @@ function envArgs(env) {
   if (!env) return [];
   return Object.entries(env).flatMap(([key, value]) => ["--env", `${key}=${value}`]);
 }
+function cwdArgs(cwd) {
+  return ["--cwd", resolvePath(cwd)];
+}
 async function tabCreate({
   label,
   cwd,
@@ -133,8 +142,7 @@ async function tabCreate({
     ...workspaceId ? ["--workspace", workspaceId] : [],
     "--label",
     label,
-    "--cwd",
-    cwd,
+    ...cwdArgs(cwd),
     ...envArgs(env),
     "--no-focus"
   ]);
@@ -183,8 +191,7 @@ async function workspaceCreate({
     "create",
     "--label",
     label,
-    "--cwd",
-    cwd,
+    ...cwdArgs(cwd),
     ...envArgs(env),
     "--no-focus"
   ]);
@@ -214,6 +221,7 @@ async function agentStart({
   cwd,
   argv,
   workspaceId,
+  tabId: targetTabId,
   env
 }) {
   const result = await execHerdr([
@@ -221,8 +229,8 @@ async function agentStart({
     "start",
     name,
     ...workspaceId ? ["--workspace", workspaceId] : [],
-    "--cwd",
-    cwd,
+    ...targetTabId ? ["--tab", targetTabId] : [],
+    ...cwdArgs(cwd),
     ...envArgs(env),
     "--no-focus",
     "--",
@@ -235,23 +243,6 @@ async function agentStart({
   }
   return { paneId, tabId };
 }
-async function paneMoveToNewTab(paneId, { label, workspaceId }) {
-  const result = await execHerdr([
-    "pane",
-    "move",
-    paneId,
-    "--new-tab",
-    ...workspaceId ? ["--workspace", workspaceId] : [],
-    "--label",
-    label,
-    "--no-focus"
-  ]);
-  const tabId = result?.move_result?.created_tab?.tab_id;
-  if (!tabId) {
-    throw new Error("Failed to move pane to a new tab: invalid response structure from herdr");
-  }
-  return { tabId };
-}
 function toAgentStatus(value) {
   return value === "working" || value === "idle" || value === "blocked" ? value : "unknown";
 }
@@ -430,15 +421,19 @@ async function startHerdrTask({
   herdr
 }) {
   const mod = herdr ?? await loadHerdr();
-  const { paneId } = await mod.agentStart({ name: label, cwd, argv, env, workspaceId });
+  const { tabId, paneId: shellPaneId } = await mod.tabCreate({ label, cwd, workspaceId, env });
+  let paneId;
   try {
-    const { tabId } = await mod.paneMoveToNewTab(paneId, { label, workspaceId });
-    return { paneId, tabId };
+    ({ paneId } = await mod.agentStart({ name: label, cwd, argv, env, workspaceId, tabId }));
   } catch (err) {
-    await mod.paneClose(paneId).catch(() => {
+    await mod.tabClose(tabId).catch(() => {
     });
     throw err;
   }
+  await mod.paneClose(shellPaneId).catch((err) => {
+    console.error(`[herdr-runner] failed to close the placeholder shell pane ${shellPaneId}: ${err}`);
+  });
+  return { paneId, tabId };
 }
 async function waitForHerdrTask(paneId, options) {
   const mod = options?.herdr ?? await loadHerdr();
@@ -534,6 +529,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, {
@@ -2997,7 +3035,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" },
@@ -3053,10 +3169,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";
   }
 }
@@ -3082,53 +3198,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";
@@ -3170,13 +3256,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() {
@@ -3217,7 +3305,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.");
@@ -3225,11 +3314,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.0",
+  "version": "0.28.0",
   "description": "CLI tool that polls GitHub Issues/PRs and delegates work to Claude CLI",
   "type": "module",
   "main": "dist/index.js",