@sma1lboy/kobe 0.7.9 → 0.7.11

package/dist/cli/index.js

@@ -70,7 +70,7 @@ var init_package = __esm(() => {
   package_default = {
     $schema: "https://json.schemastore.org/package.json",
     name: "@sma1lboy/kobe",
-    version: "0.7.9",
+    version: "0.7.11",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -5019,6 +5019,50 @@ function matchTaskByCwd(tasks, cwd) {
   }
   return bestId;
 }
+function matchRepoByCwd(tasks, cwd) {
+  const target = normalize(cwd);
+  let best;
+  let bestLen = -1;
+  for (const t of tasks) {
+    if (!t.repo)
+      continue;
+    const repo = normalize(t.repo);
+    if (isAncestorOrSelf(repo, target) && repo.length > bestLen) {
+      bestLen = repo.length;
+      best = repo;
+    }
+  }
+  return best;
+}
+function findAdoptableWorktree(tasks, cwd) {
+  const target = normalize(cwd);
+  const repos = new Set;
+  const known = new Set;
+  for (const t of tasks) {
+    if (t.repo)
+      repos.add(normalize(t.repo));
+    if (t.worktreePath)
+      known.add(normalize(t.worktreePath));
+  }
+  const seg = `/${KOBE_WORKTREE_ROOT_SUBPATH}/`;
+  for (const repo of repos) {
+    const prefix = `${repo}${seg}`;
+    if (!target.startsWith(prefix))
+      continue;
+    const rest = target.slice(prefix.length);
+    const name = rest.split("/")[0];
+    if (!name)
+      continue;
+    const worktreePath = `${prefix}${name}`;
+    if (known.has(worktreePath))
+      return;
+    return { repo, worktreePath };
+  }
+  return;
+}
+var init_cwd_task = __esm(() => {
+  init_paths();
+});
 
 // src/daemon/event-bus.ts
 class DaemonEventBus {
@@ -5335,6 +5379,20 @@ async function startDaemonServer(orch, options = {}) {
         });
         return { task: serializeTask(task) };
       }
+      case "worktree.reconcile": {
+        const cwd = requireString(payload, "cwd");
+        const worktreePath = requireString(payload, "worktreePath");
+        const repo = matchRepoByCwd(orch.listTasks(), cwd) ?? matchRepoByCwd(orch.listTasks(), worktreePath);
+        if (!repo)
+          return { adopted: false };
+        try {
+          const task = await orch.adoptWorktree({ repo, worktreePath, ifExists: "return" });
+          return { adopted: true, taskId: task.id };
+        } catch (err) {
+          logDaemonError("worktree-created", err);
+          return { adopted: false };
+        }
+      }
       case "task.setActive": {
         bus.publish("active-task", { taskId: optionalString(payload, "taskId") ?? null });
         return {};
@@ -5345,6 +5403,16 @@ async function startDaemonServer(orch, options = {}) {
           throw new Error(`unknown engine event kind: ${kind}`);
         const explicitId = optionalString(payload, "taskId");
         const cwd = optionalString(payload, "cwd");
+        if (!explicitId && cwd && kind === "session-start") {
+          const cand = findAdoptableWorktree(orch.listTasks(), cwd);
+          if (cand) {
+            try {
+              await orch.adoptWorktree({ repo: cand.repo, worktreePath: cand.worktreePath, ifExists: "return" });
+            } catch (err) {
+              logDaemonError("worktree-autosync", err);
+            }
+          }
+        }
         const taskId = explicitId ?? (cwd ? matchTaskByCwd(orch.listTasks(), cwd) : undefined);
         if (!taskId)
           return {};
@@ -5491,6 +5559,7 @@ var init_server = __esm(() => {
   init_hook_events();
   init_version();
   init_auto_title_poller();
+  init_cwd_task();
   init_paths2();
   init_protocol();
   DEFAULT_UPDATE_POLL_MS = 6 * 60 * 60 * 1000;
@@ -8365,6 +8434,29 @@ function mergeActivityHooks(current, install, inv = kobeCliInvocation()) {
   }
   return Object.keys(hooks).length > 0 ? { ...restSettings, hooks } : { ...restSettings };
 }
+function buildWorktreeWatchHook(inv = kobeCliInvocation()) {
+  const command = shellQuoteArgv([...inv, "hook", WORKTREE_SYNC_MARKER]);
+  return { PostToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command }] }] };
+}
+function isKobeWorktreeWatchGroup(group) {
+  if (!isObject6(group) || !Array.isArray(group.hooks))
+    return false;
+  return group.hooks.some((h) => isObject6(h) && typeof h.command === "string" && h.command.includes(WORKTREE_SYNC_MARKER));
+}
+function mergeWorktreeWatchHook(current, install, inv = kobeCliInvocation()) {
+  const { hooks: rawHooks, ...restSettings } = current;
+  const hooks = isObject6(rawHooks) ? { ...rawHooks } : {};
+  const key = "PostToolUse";
+  const prior = Array.isArray(hooks[key]) ? hooks[key] : [];
+  const kept = prior.filter((g) => !isKobeWorktreeWatchGroup(g));
+  if (install)
+    kept.push(...buildWorktreeWatchHook(inv)[key]);
+  if (kept.length > 0)
+    hooks[key] = kept;
+  else
+    delete hooks[key];
+  return Object.keys(hooks).length > 0 ? { ...restSettings, hooks } : { ...restSettings };
+}
 
 class ClaudeHookAdapter {
   vendor = "claude";
@@ -8380,13 +8472,15 @@ class ClaudeHookAdapter {
   async removeActivityHooks(settingsFilePath) {
     await this.editSettings(settingsFilePath, (cur) => mergeActivityHooks(cur, false));
   }
-  async installWorktreeSyncHook(settingsFilePath) {
-    const command = shellQuoteArgv([...kobeCliInvocation(), "hook", "worktree-created"]);
-    await this.editSettings(settingsFilePath, (cur) => mergeWorktreeSyncHook(cur, command));
-  }
   async removeWorktreeSyncHook(settingsFilePath) {
     await this.editSettings(settingsFilePath, (cur) => mergeWorktreeSyncHook(cur, null));
   }
+  async installWorktreeWatchHook(settingsFilePath) {
+    await this.editSettings(settingsFilePath, (cur) => mergeWorktreeWatchHook(cur, true));
+  }
+  async removeWorktreeWatchHook(settingsFilePath) {
+    await this.editSettings(settingsFilePath, (cur) => mergeWorktreeWatchHook(cur, false));
+  }
   async editSettings(settingsFilePath, transform) {
     try {
       const current = await readJsonObject(settingsFilePath);
@@ -8434,8 +8528,9 @@ class NoopHookAdapter {
   supportsWorktreeSync() {
     return false;
   }
-  async installWorktreeSyncHook() {}
   async removeWorktreeSyncHook() {}
+  async installWorktreeWatchHook() {}
+  async removeWorktreeWatchHook() {}
 }
 var init_hook_adapter2 = __esm(() => {
   init_hook_adapter();
@@ -8445,10 +8540,11 @@ var init_hook_adapter2 = __esm(() => {
 var exports_hook_cmd = {};
 __export(exports_hook_cmd, {
   runHookSubcommand: () => runHookSubcommand,
+  parseWorktreeAddPath: () => parseWorktreeAddPath,
   ensureGlobalKobeHooks: () => ensureGlobalKobeHooks
 });
 import { homedir as homedir10 } from "os";
-import { dirname as dirname7, join as join9, resolve as resolve6 } from "path";
+import { join as join9, resolve as resolve6 } from "path";
 async function readStdinPayload() {
   try {
     const text = await Promise.race([
@@ -8481,17 +8577,70 @@ function flagValue(argv, name) {
   }
   return;
 }
+function isPlainObject2(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function tokenizeCommand(command) {
+  const out = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(command)) !== null)
+    out.push(m[1] ?? m[2] ?? m[3] ?? "");
+  return out;
+}
+function parseWorktreeAddPath(command) {
+  const tokens = tokenizeCommand(command);
+  const valueFlags = new Set(["-b", "-B", "--reason"]);
+  for (let i = 0;i + 1 < tokens.length; i++) {
+    if (tokens[i] !== "worktree" || tokens[i + 1] !== "add")
+      continue;
+    let j = i + 2;
+    while (j < tokens.length) {
+      const t = tokens[j];
+      if (t === "&&" || t === "||" || t === ";" || t === "|" || t === ">" || t === ">>")
+        break;
+      if (t.startsWith("-")) {
+        j += valueFlags.has(t) ? 2 : 1;
+        continue;
+      }
+      return t;
+    }
+  }
+  return;
+}
+async function runWorktreeCreatedHook() {
+  const payload = await readStdinPayload();
+  const toolInput = isPlainObject2(payload.tool_input) ? payload.tool_input : {};
+  const command = typeof toolInput.command === "string" ? toolInput.command : "";
+  if (!command.includes("worktree"))
+    return;
+  const rawPath = parseWorktreeAddPath(command);
+  if (!rawPath)
+    return;
+  const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
+  const worktreePath = resolve6(cwd, rawPath);
+  const client = await connectIfRunning();
+  if (!client)
+    return;
+  try {
+    await client.request("worktree.reconcile", { cwd, worktreePath });
+  } finally {
+    client.close();
+  }
+}
 async function runHookSubcommand(argv) {
   const [verb, ...rest] = argv;
   if (verb === "setup") {
     await runHookSetup(rest);
     return;
   }
+  if (verb === WORKTREE_CREATED_VERB) {
+    try {
+      await runWorktreeCreatedHook();
+    } catch {}
+    return;
+  }
   try {
-    if (verb === "worktree-created") {
-      await reportWorktreeCreated();
-      return;
-    }
     if (!verb || !isEngineActivityKind(verb))
       return;
     const payload = await readStdinPayload();
@@ -8517,43 +8666,6 @@ async function runHookSubcommand(argv) {
     }
   } catch {}
 }
-async function reportWorktreeCreated() {
-  const payload = await readStdinPayload();
-  const worktreePath = typeof payload.worktree_path === "string" ? payload.worktree_path : undefined;
-  if (!worktreePath)
-    return;
-  const repo = await deriveRepoRoot(worktreePath);
-  if (!repo)
-    return;
-  const client = await connectIfRunning();
-  if (!client)
-    return;
-  try {
-    await client.request("worktree.adopt", { repo, worktreePath, ifExists: "return" });
-  } finally {
-    client.close();
-  }
-}
-async function deriveRepoRoot(worktreePath) {
-  try {
-    const proc = Bun.spawn(["git", "-C", worktreePath, "rev-parse", "--path-format=absolute", "--git-common-dir"], {
-      stdout: "pipe",
-      stderr: "ignore"
-    });
-    const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
-    if (code !== 0)
-      return;
-    const commonDir = out.trim();
-    return commonDir ? dirname7(commonDir) : undefined;
-  } catch {
-    return;
-  }
-}
-function syncSettingsPath(scope) {
-  if (scope.kind === "repo")
-    return join9(resolve6(scope.path), ".claude", "settings.json");
-  return globalSettingsPath();
-}
 function worktreeSyncAdapters() {
   return ALL_VENDORS.map((v) => createEngineHookAdapter(v)).filter((a) => a.supportsWorktreeSync());
 }
@@ -8567,84 +8679,53 @@ function persistedSyncPath(stored) {
   if (!stored || stored === "off")
     return;
   if (stored === "global")
-    return syncSettingsPath({ kind: "global" });
+    return globalSettingsPath();
   if (stored.startsWith("repo:"))
-    return syncSettingsPath({ kind: "repo", path: stored.slice(5) });
+    return join9(resolve6(stored.slice(5)), ".claude", "settings.json");
   return stored;
 }
 async function ensureGlobalKobeHooks() {
   try {
     const globalPath = globalSettingsPath();
-    for (const a of activityHookAdapters())
+    for (const a of activityHookAdapters()) {
       await a.installActivityHooks(globalPath);
-    const stored = getPersistedString(SYNC_SETTING_KEY);
-    if (stored === "off")
-      return;
-    const syncAdapters = worktreeSyncAdapters();
-    if (syncAdapters.length === 0)
-      return;
-    const path6 = persistedSyncPath(stored) ?? syncSettingsPath({ kind: "global" });
-    for (const a of syncAdapters)
-      await a.installWorktreeSyncHook(path6);
-    if (!stored)
-      setPersistedString(SYNC_SETTING_KEY, path6);
+      await a.installWorktreeWatchHook(globalPath);
+    }
+    await cleanupWorktreeSyncHook();
   } catch {}
 }
-async function runHookSetup(argv) {
-  if (argv.includes("--help") || argv.includes("-h")) {
-    process.stdout.write([
-      "Usage: kobe hook setup [--global | --repo <path> | --off]",
-      "",
-      "Syncs an external `claude --worktree` into kobe as a task. This is ON",
-      "by default (installed globally into ~/.claude on launch). Use this to",
-      "move it to one repo (--repo <path>) or to turn it OFF (--off).",
-      ""
-    ].join(`
-`));
-    return;
-  }
-  const off = argv.includes("--off");
-  const repoIdx = argv.indexOf("--repo");
-  const repoPath = repoIdx !== -1 ? argv[repoIdx + 1] : undefined;
-  if (repoIdx !== -1 && !repoPath) {
-    process.stderr.write(`kobe hook setup: --repo requires a path
-`);
-    process.exit(2);
-  }
+async function cleanupWorktreeSyncHook() {
   const adapters = worktreeSyncAdapters();
-  if (adapters.length === 0) {
-    process.stdout.write(`kobe hook setup: no engine supports external worktree sync \u2014 nothing to do
-`);
+  if (adapters.length === 0)
     return;
-  }
-  const prevPath = persistedSyncPath(getPersistedString(SYNC_SETTING_KEY));
-  if (off) {
-    if (prevPath) {
-      for (const a of adapters)
-        await a.removeWorktreeSyncHook(prevPath);
-    }
-    setPersistedString(SYNC_SETTING_KEY, "off");
-    process.stdout.write(`kobe hook setup: external worktree sync disabled${prevPath ? ` (removed from ${prevPath})` : ""}
-`);
-    return;
-  }
-  const scope = repoPath ? { kind: "repo", path: repoPath } : { kind: "global" };
-  const path6 = syncSettingsPath(scope);
-  if (prevPath && prevPath !== path6) {
-    for (const a of adapters)
-      await a.removeWorktreeSyncHook(prevPath);
-  }
+  const stored = getPersistedString(SYNC_SETTING_KEY);
+  const paths = new Set([globalSettingsPath()]);
+  const prev = persistedSyncPath(stored);
+  if (prev)
+    paths.add(prev);
   for (const a of adapters)
-    await a.installWorktreeSyncHook(path6);
-  setPersistedString(SYNC_SETTING_KEY, path6);
+    for (const p of paths)
+      await a.removeWorktreeSyncHook(p);
+  if (stored !== "off")
+    setPersistedString(SYNC_SETTING_KEY, "off");
+}
+async function runHookSetup(_argv) {
+  await cleanupWorktreeSyncHook();
   process.stdout.write([
-    `kobe hook setup: external worktree sync enabled (${scope.kind}) \u2014 wrote ${path6}`,
-    "New `claude --worktree` worktrees will appear as kobe tasks.",
+    "kobe hook setup is deprecated and now a no-op (cleanup only).",
+    "",
+    "The old external-worktree sync used a global WorktreeCreate hook, which is",
+    "a VCS provider hook \u2014 its presence broke `claude --worktree` / EnterWorktree",
+    "in every repo. Any hook kobe previously installed has been removed.",
+    "",
+    "Sync is now automatic: a `claude --worktree` (or any session) started in a",
+    "worktree under a repo kobe already tracks is adopted as a task on launch.",
+    "To adopt existing worktrees on demand, use the New Task dialog or `kobe adopt`.",
     ""
   ].join(`
 `));
 }
-var SYNC_SETTING_KEY = "externalWorktreeSync";
+var WORKTREE_CREATED_VERB = "worktree-created", SYNC_SETTING_KEY = "externalWorktreeSync";
 var init_hook_cmd = __esm(() => {
   init_daemon_process();
   init_hook_adapter2();
@@ -15988,7 +16069,7 @@ var init_focus = __esm(() => {
 
 // src/tui/context/kv.tsx
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname7 } from "path";
 function loadInitial() {
   const statePath2 = kvStatePath();
   try {
@@ -16016,7 +16097,7 @@ var init_kv = __esm(() => {
       function writeNow(label) {
         const statePath2 = kvStatePath();
         try {
-          mkdirSync4(dirname8(statePath2), {
+          mkdirSync4(dirname7(statePath2), {
             recursive: true
           });
           const tmp = `${statePath2}.tmp`;
@@ -16071,7 +16152,7 @@ var init_kv = __esm(() => {
           }
           const statePath2 = kvStatePath();
           try {
-            mkdirSync4(dirname8(statePath2), {
+            mkdirSync4(dirname7(statePath2), {
               recursive: true
             });
             const tmp = `${statePath2}.tmp`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@sma1lboy/kobe",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "TUI orchestrator for Claude Code (codename)",
   "type": "module",
   "packageManager": "bun@1.3.13",