@norman-else/dsh-claude 0.1.36 → 0.1.37

package/lib/index.mjs

@@ -3,12 +3,12 @@ import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicP
 import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-loenwnLS.mjs";
 import z from "@deepseek-ai/schemastery";
 import { createHash, randomUUID } from "node:crypto";
-import { chmod, mkdir, opendir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { chmod, mkdir, opendir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { homedir } from "node:os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { CallId, LlmAdapter, ReasoningEffortId, createToolResultMessage } from "@deepseek-ai/dsh-llm";
+import { LlmAdapter, ReasoningEffortId, ToolCallId, createToolResultMessage } from "@deepseek-ai/dsh-llm";
 import { EventEmitter } from "node:events";
 import { DSH_ENV_PREFIX, SENSITIVE_ENV_PATTERN } from "@deepseek-ai/dsh-subprocess";
 import { fileURLToPath } from "node:url";
@@ -2067,7 +2067,7 @@ var ClaudeSupervisor = class {
 			await active.agent.session.append("tool/call", {
 				turn: active.cursor.turn,
 				step: active.cursor.step,
-				callId: CallId(message.toolUseId),
+				callId: ToolCallId(message.toolUseId),
 				name: message.toolName,
 				arguments: safeDetail(message.input) ?? "{}"
 			});
@@ -2080,7 +2080,7 @@ var ClaudeSupervisor = class {
 				turn: active.cursor.turn,
 				step: active.cursor.step,
 				message: createToolResultMessage({
-					callId: CallId(message.toolUseId),
+					callId: ToolCallId(message.toolUseId),
 					content: [{
 						type: "text",
 						text
@@ -3977,6 +3977,90 @@ var RepositoryStatusService = class {
 	}
 };
 //#endregion
+//#region src/branch-name.ts
+/** Name a generated worktree branch after what the user is about to ask for.
+*
+*  The composer draft is the only description of the work that exists before
+*  the session starts, and it is usually not English and never branch-safe, so
+*  a throwaway Haiku turn compresses it into a slug. Naming is a nicety: every
+*  failure here returns `undefined` and the caller keeps its timestamped name. */
+/** Cheapest model that can translate and compress a sentence. */
+const BRANCH_SUMMARY_MODEL = "haiku";
+/** A branch name is not worth blocking worktree creation on for long. */
+const BRANCH_SUMMARY_TIMEOUT_MS = 15e3;
+const MAX_INTENT_CHARS = 2e3;
+/** A compliant reply is one short fragment; anything longer is prose. */
+const MAX_REPLY_CHARS$2 = 80;
+/** More words than this is a sentence, not the fragment we asked for. */
+const MAX_SLUG_WORDS = 6;
+const MAX_SLUG_CHARS = 48;
+function branchSummaryPrompt(intent) {
+	return [
+		"Summarize this software task as a Git branch name fragment.",
+		"Reply with 2-5 lowercase English words joined by hyphens and nothing else:",
+		"no quotes, no slashes, no prefix, no punctuation, no explanation.",
+		"Translate the task to English if it is written in another language.",
+		"",
+		"Task:",
+		`"""\n${intent.replaceAll("\"\"\"", "\" \" \"")}\n"""`
+	].join("\n");
+}
+/** Branch-safe slug for a model reply, or `undefined` when the reply is not
+*  the fragment we asked for. Mangling a refusal or a paragraph into a slug
+*  would produce a worse name than the timestamped fallback. */
+function branchSlug(reply) {
+	const line = reply.trim();
+	if (line.length === 0 || line.length > MAX_REPLY_CHARS$2 || /[\r\n]/u.test(line)) return void 0;
+	const words = line.toLocaleLowerCase("en-US").replace(/[^a-z0-9]+/gu, "-").split("-").filter((word) => word.length > 0);
+	if (words.length === 0 || words.length > MAX_SLUG_WORDS) return void 0;
+	const slug = words.join("-").slice(0, MAX_SLUG_CHARS).replace(/-+$/u, "");
+	return slug.length === 0 ? void 0 : slug;
+}
+/** First free name in `<candidate>`, `<candidate>-2`, `<candidate>-3`, … */
+function uniqueBranchName(candidate, taken) {
+	const existing = new Set(taken);
+	if (!existing.has(candidate)) return candidate;
+	for (let index = 2; index < 100; index += 1) {
+		const name = `${candidate}-${index}`;
+		if (!existing.has(name)) return name;
+	}
+	return candidate;
+}
+/** Compress a composer draft into a branch slug with a throwaway Claude turn.
+*
+*  Deliberately NOT routed through the supervisor, for the same reasons as the
+*  plan-usage probe: there is no session to borrow yet. The turn is isolated
+*  from filesystem settings as well, because a CLAUDE.md instruction ("always
+*  reply in the user's language") turns the answer into an unusable slug. */
+async function summarizeBranchSlug(executablePath, intent, factory = query) {
+	const task = intent.trim().slice(0, MAX_INTENT_CHARS);
+	if (task.length === 0) return void 0;
+	const lifetime = new AbortController();
+	const timer = setTimeout(() => lifetime.abort(), BRANCH_SUMMARY_TIMEOUT_MS);
+	timer.unref?.();
+	try {
+		const query = factory({
+			prompt: branchSummaryPrompt(task),
+			options: {
+				cwd: process.cwd(),
+				abortController: lifetime,
+				model: BRANCH_SUMMARY_MODEL,
+				allowedTools: [],
+				settingSources: [],
+				maxTurns: 1,
+				...executablePath.length === 0 ? {} : { pathToClaudeCodeExecutable: executablePath }
+			}
+		});
+		for await (const message of query) if (message.type === "result" && message.subtype === "success") return branchSlug(message.result);
+		return;
+	} catch {
+		return;
+	} finally {
+		clearTimeout(timer);
+		lifetime.abort();
+	}
+}
+//#endregion
 //#region src/repository-setup.ts
 const MAX_OUTPUT_BYTES$3 = 131072;
 const GIT_TIMEOUT_MS$2 = 1e4;
@@ -4054,6 +4138,7 @@ var RepositorySetupService = class {
 	#leasePath;
 	#worktreeRoot;
 	#branchPrefix;
+	#summarizeBranch;
 	#cleanupGraceMs;
 	#gitPath;
 	#pending = Promise.resolve();
@@ -4062,6 +4147,7 @@ var RepositorySetupService = class {
 		this.#leasePath = options.leasePath ?? dshHomePath("plugins", "dsh-claude", "worktrees.json");
 		this.#worktreeRoot = options.worktreeRoot ?? dshHomePath("plugins", "dsh-claude", "worktrees");
 		this.#branchPrefix = options.branchPrefix ?? (async () => "claude");
+		this.#summarizeBranch = options.summarizeBranch ?? (async () => void 0);
 		this.#cleanupGraceMs = options.cleanupGraceMs ?? CLEANUP_GRACE_MS;
 	}
 	async listBranches(cwd) {
@@ -4108,7 +4194,7 @@ var RepositorySetupService = class {
 			remoteBranches
 		};
 	}
-	async setup(cwd, branchValue, useWorktree, explicitBranchName, progress = () => {}) {
+	async setup(cwd, branchValue, useWorktree, explicitBranchName, progress = () => {}, intent) {
 		progress("inspecting");
 		const branch = safeBranch(branchValue);
 		const info = await this.listBranches(cwd);
@@ -4116,7 +4202,7 @@ var RepositorySetupService = class {
 		const remote = info.remoteBranches.includes(branch);
 		if (!local && !remote) throw new RepositorySetupError("branch-not-found", "The selected local or remote-tracking branch does not exist.");
 		const requestedBranch = explicitBranchName === void 0 ? void 0 : safeBranch(explicitBranchName);
-		if (useWorktree) return this.#createWorktree(info.root, branch, local ? `refs/heads/${branch}` : `refs/remotes/${branch}`, requestedBranch, requestedBranch !== void 0 && info.branches.includes(requestedBranch), progress);
+		if (useWorktree) return this.#createWorktree(info, branch, local ? `refs/heads/${branch}` : `refs/remotes/${branch}`, requestedBranch, requestedBranch !== void 0 && info.branches.includes(requestedBranch), progress, intent);
 		progress("switching-branch");
 		return !local && remote ? this.#checkoutRemote(info, branch) : this.#checkout(info, branch);
 	}
@@ -4199,11 +4285,17 @@ var RepositorySetupService = class {
 		});
 	}
 	/** Reconcile leases against the set of directories still referenced by a
-	*  workspace: an unreferenced lease's clean worktree is removed. Fresh
-	*  leases are retained for a grace period so a worktree created moments ago
-	*  cannot be swept before its workspace registration lands, and dirty
-	*  worktrees are always retained to avoid losing uncommitted work. */
-	cleanupOrphans(activePaths) {
+	*  workspace. Deleting a workspace is the user saying they are done with it,
+	*  so an unreferenced worktree goes even with uncommitted changes; its
+	*  sessions are archived first, through `archiveSessions`, or the Host
+	*  rebuilds the deleted workspace from their headers on the next boot.
+	*  Fresh leases are retained for a grace period so a worktree created
+	*  moments ago cannot be swept before its workspace registration lands.
+	*
+	*  Every command runs from the repository root, never from the worktree
+	*  being removed: spawning in a directory that is already gone throws
+	*  ENOENT, which used to strand the lease forever. */
+	cleanupOrphans(activePaths, archiveSessions) {
 		const active = new Set(activePaths.map(comparablePath));
 		return this.#serialize(async () => {
 			const leases = await this.#readLeases();
@@ -4218,32 +4310,19 @@ var RepositorySetupService = class {
 					continue;
 				}
 				try {
-					const status = await this.#run(git, [
-						"status",
-						"--porcelain=v1",
-						"--untracked-files=normal"
-					], item.path);
-					if (status.exitCode !== 0 || status.lossy) {
-						if (await pathExists(item.path)) retained.push(item);
-						else {
-							await this.#run(git, ["worktree", "prune"], item.root).catch(() => void 0);
-							changed = true;
+					await archiveSessions?.(item.path).catch(() => void 0);
+					if (await pathExists(item.path)) {
+						if ((await this.#run(git, [
+							"worktree",
+							"remove",
+							"--force",
+							"--",
+							item.path
+						], item.root)).exitCode !== 0) {
+							retained.push(item);
+							continue;
 						}
-						continue;
-					}
-					if (status.stdout.trim().length > 0) {
-						retained.push(item);
-						continue;
-					}
-					if ((await this.#run(git, [
-						"worktree",
-						"remove",
-						"--",
-						item.path
-					], item.root)).exitCode !== 0) {
-						retained.push(item);
-						continue;
-					}
+					} else await this.#run(git, ["worktree", "prune"], item.root).catch(() => void 0);
 					if (item.pluginGeneratedBranch) await this.#run(git, [
 						"branch",
 						"-D",
@@ -4257,8 +4336,38 @@ var RepositorySetupService = class {
 				}
 			}
 			if (changed) await this.#writeLeases(retained);
+			await this.#removeUnleasedDirectories(retained, active, now);
 		});
 	}
+	/** Remove directories under the plugin's own worktree root that no lease and
+	*  no workspace claims. A lease file lost to a crash, or a worktree whose
+	*  lease write failed, otherwise leaves a directory nothing will ever sweep.
+	*  The grace period covers the gap between `worktree add` and the lease
+	*  write, so a worktree being created right now is never taken. */
+	async #removeUnleasedDirectories(retained, active, now) {
+		const leased = new Set(retained.map((item) => comparablePath(item.path)));
+		let entries;
+		try {
+			entries = await readdir(this.#worktreeRoot);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const path = join(this.#worktreeRoot, entry);
+			const key = comparablePath(path);
+			if (leased.has(key) || active.has(key)) continue;
+			try {
+				const info = await stat(path);
+				if (!info.isDirectory()) continue;
+				const created = info.birthtimeMs > 0 ? info.birthtimeMs : info.mtimeMs;
+				if (Math.max(0, now - created) < this.#cleanupGraceMs) continue;
+				await rm(path, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	}
 	async #checkoutRemote(info, remoteBranch) {
 		const separator = remoteBranch.indexOf("/");
 		if (separator <= 0 || separator === remoteBranch.length - 1) throw new RepositorySetupError("invalid-branch", "The remote-tracking branch name is invalid.");
@@ -4325,13 +4434,14 @@ var RepositorySetupService = class {
 			branch
 		};
 	}
-	async #createWorktree(root, baseBranch, baseRef, explicitBranchName, reuseExistingBranch, progress) {
+	async #createWorktree(info, baseBranch, baseRef, explicitBranchName, reuseExistingBranch, progress, intent) {
+		const { root } = info;
 		const git = await this.#git();
 		progress("fetching");
 		await this.#fetchRemotes(git, root);
 		const suffix = randomUUID().slice(0, 8);
 		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace(/\.\d{3}Z$/u, "Z");
-		const branch = explicitBranchName ?? `${safeBranch(await this.#branchPrefix())}/${slug(baseBranch, "branch")}-${stamp}-${suffix}`;
+		const branch = explicitBranchName ?? await this.#generatedBranch(info, baseBranch, intent, stamp, suffix, progress);
 		const path = join(this.#worktreeRoot, `${slug(basename(root), "repository")}-${stamp}-${suffix}`);
 		progress("creating-worktree");
 		await mkdir(this.#worktreeRoot, { recursive: true });
@@ -4392,6 +4502,18 @@ var RepositorySetupService = class {
 			leaseId: item.id
 		};
 	}
+	/** `<prefix>/<what the draft is about>`, falling back to
+	*  `<prefix>/<base branch>-<stamp>-<random>` whenever the summary is missing
+	*  or unusable. The prefix and the fallback shape are unchanged. */
+	async #generatedBranch(info, baseBranch, intent, stamp, suffix, progress) {
+		const prefix = safeBranch(await this.#branchPrefix());
+		if (intent !== void 0 && intent.trim().length > 0) {
+			progress("summarizing");
+			const summary = await this.#summarizeBranch(intent).catch(() => void 0);
+			if (summary !== void 0) return uniqueBranchName(`${prefix}/${summary}`, info.branches);
+		}
+		return `${prefix}/${slug(baseBranch, "branch")}-${stamp}-${suffix}`;
+	}
 	async #repositoryRoot(git, cwd) {
 		const result = await this.#run(git, [
 			"rev-parse",
@@ -4964,7 +5086,7 @@ async function streamSetup(res, service, input) {
 					type: "progress",
 					stage
 				});
-			})
+			}, optionalString$1(input, "intent"))
 		});
 	} catch (error) {
 		const setupError = error instanceof RepositorySetupError ? error : void 0;
@@ -7650,7 +7772,10 @@ async function apply(ctx, config) {
 	await applySettingsOverrides();
 	const sidecar = new ClaudeSidecarRepository();
 	const repositoryStatus = new RepositoryStatusService(ctx.subprocess);
-	const repositorySetup = new RepositorySetupService(ctx.subprocess, { branchPrefix: () => readWorktreeBranchPrefix() });
+	const repositorySetup = new RepositorySetupService(ctx.subprocess, {
+		branchPrefix: () => readWorktreeBranchPrefix(),
+		summarizeBranch: (intent) => summarizeBranchSlug(supervisorConfig.executablePath, intent)
+	});
 	const reviewComments = new ReviewCommentStore();
 	const commandCatalogs = /* @__PURE__ */ new Map();
 	const supervisor = new ClaudeSupervisor({
@@ -7730,10 +7855,20 @@ async function apply(ctx, config) {
 	});
 	const injectWorkspaceRegistry = ctx.inject;
 	injectWorkspaceRegistry(["workspaceRegistry"], (sweepCtx) => {
+		const archiveSessions = async (worktreePath) => {
+			const persistence = sweepCtx.get("sessionPersistence");
+			if (persistence === void 0) return;
+			const target = comparablePath(worktreePath);
+			for (const header of await persistence.list()) {
+				if (typeof header.id !== "string" || typeof header.cwd !== "string") continue;
+				if (comparablePath(header.cwd) !== target) continue;
+				await sweepCtx.workspaceRegistry.archiveSession(header.id).catch(() => void 0);
+			}
+		};
 		const sweep = () => {
 			try {
 				const paths = sweepCtx.workspaceRegistry.list().map((workspace) => workspace.path);
-				repositorySetup.cleanupOrphans(paths).catch(() => void 0);
+				repositorySetup.cleanupOrphans(paths, archiveSessions).catch(() => void 0);
 			} catch {}
 		};
 		sweepCtx.effect(() => {