@norman-else/dsh-claude 0.1.38 → 0.1.40

package/lib/index.mjs

@@ -1180,6 +1180,80 @@ function normalizeSdkMessage(message) {
 	}];
 }
 //#endregion
+//#region src/model-catalog.ts
+/** What the selector shows before any session has initialized in this Host
+*  process -- a fresh app launch lands here. `default` is the only id that is
+*  valid on every release and plan; the aliases after it are the stable
+*  `/model` spellings Claude Code has kept across releases, so the menu is
+*  usable at first paint instead of a single row. The first initialize
+*  response replaces the whole list with the CLI's own lineup. */
+const SEED = [
+	{
+		id: "default",
+		name: "Default (recommended)",
+		description: ""
+	},
+	{
+		id: "opus[1m]",
+		name: "Opus (1M context)",
+		description: "",
+		contextWindow: 1e6
+	},
+	{
+		id: "fable",
+		name: "Fable",
+		description: ""
+	},
+	{
+		id: "sonnet",
+		name: "Sonnet",
+		description: ""
+	},
+	{
+		id: "haiku",
+		name: "Haiku",
+		description: ""
+	}
+];
+/** A 1M-context route spells it in the id (`opus[1m]`, `claude-fable-5[1m]`),
+*  so this needs no capacity table either. It is only a floor: the supervisor
+*  overrides it with the window the CLI reports once a turn has run. */
+function declaredContextWindow(row) {
+	return /\[1m\]$/u.test(row.resolvedModel ?? row.value) ? 1e6 : void 0;
+}
+function projectModel(row) {
+	const contextWindow = declaredContextWindow(row);
+	return {
+		id: row.value,
+		name: row.displayName,
+		description: row.description,
+		...contextWindow === void 0 ? {} : { contextWindow }
+	};
+}
+let latest$1;
+/**
+* Learn the lineup from one session's initialize response.
+* @param models - the CLI's own `/model` rows; an empty list is ignored so a
+*   CLI that answers without a catalog cannot blank the selector.
+*/
+function recordClaudeModels(models) {
+	if (models.length === 0) return;
+	latest$1 = models.map(projectModel);
+}
+/** The lineup to advertise: whatever the CLI last reported, else the seed. */
+function latestClaudeModels() {
+	return latest$1 ?? SEED;
+}
+/**
+* Look one id up in the current lineup.
+* @param id - the id DSH persisted on the session, which may name a model the
+*   running CLI no longer lists.
+* @returns the row, or undefined when the lineup does not cover the id.
+*/
+function claudeModelRow(id) {
+	return latestClaudeModels().find((row) => row.id === id);
+}
+//#endregion
 //#region src/plan-usage.ts
 /** Claude.ai plan rate-limit windows behind the CLI's `/usage` panel.
 *
@@ -1508,9 +1582,11 @@ var ClaudeSupervisor = class {
 		return this.#runMetadata(agent, model, (query) => query.supportedCommands());
 	}
 	async contextUsage(agent, model = this.#config.defaultModel) {
-		const usage = await this.#runMetadata(agent, model, (query) => query.getContextUsage());
-		this.#recordContextWindow(model, usage);
-		return usage;
+		return this.#runMetadata(agent, model, async (query, entry) => {
+			const usage = await query.getContextUsage();
+			this.#recordContextWindow(entry.model, usage);
+			return usage;
+		});
 	}
 	/** Cache a window under both the selector id the caller asked for and the
 	*  concrete model the CLI reports, so either name resolves it later. */
@@ -1581,19 +1657,13 @@ var ClaudeSupervisor = class {
 			entry.idleTimer = void 0;
 		}
 		const model = request.model ?? this.#config.defaultModel;
-		if (request.thinkingMode !== entry.thinkingMode) {
+		if (request.thinkingMode !== entry.thinkingMode || model !== entry.model) {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
 			entry = await this.#createEntry(request.agent, model, request.thinkingMode);
 			this.#entries.set(sessionId, entry);
 			await entry.sdkInitialization;
-		} else {
-			await this.#syncPermissionMode(entry);
-			if (model !== entry.model) {
-				await this.#control(entry, entry.query.setModel(model), "Claude Code model switch");
-				entry.model = model;
-			}
-		}
+		} else await this.#syncPermissionMode(entry);
 		const promptUuid = randomUUID();
 		const cursor = currentClaudeActivityCursor(request.agent.session.events);
 		cursor.nextOrdinal = (await this.#sidecar.read(sessionId)).activities.reduce((next, activity) => activity.turn === cursor.turn && activity.step === cursor.step ? Math.max(next, activity.ordinal + 1) : next, 0);
@@ -1692,10 +1762,6 @@ var ClaudeSupervisor = class {
 			entry.idleTimer = void 0;
 		}
 		await this.#syncPermissionMode(entry);
-		if (model !== entry.model) {
-			await this.#control(entry, entry.query.setModel(model), "Claude Code model switch");
-			entry.model = model;
-		}
 		return entry;
 	}
 	/** Run one SDK control request against a live entry, and discard the entry if
@@ -1831,7 +1897,8 @@ var ClaudeSupervisor = class {
 			options
 		});
 		entry.pump = this.#runDetached(() => this.#pump(entry));
-		entry.sdkInitialization = withTimeout(entry.query.initializationResult(), CLAUDE_INITIALIZATION_TIMEOUT_MS, "Claude SDK initialization").then(() => {
+		entry.sdkInitialization = withTimeout(entry.query.initializationResult(), CLAUDE_INITIALIZATION_TIMEOUT_MS, "Claude SDK initialization").then((initialization) => {
+			recordClaudeModels(initialization.models);
 			if (entry.state === "starting") entry.state = "idle";
 		});
 		entry.sdkInitialization.catch((error) => this.#handleDisconnect(entry, error));
@@ -2604,34 +2671,6 @@ function formatReviewComments(comments) {
 }
 //#endregion
 //#region src/adapter.ts
-const MODELS = [
-	{
-		id: "default",
-		name: "Default (recommended)",
-		description: ""
-	},
-	{
-		id: "opus[1m]",
-		name: "Opus (1M context)",
-		description: "",
-		contextWindow: 1e6
-	},
-	{
-		id: "fable",
-		name: "Fable",
-		description: ""
-	},
-	{
-		id: "sonnet",
-		name: "Sonnet",
-		description: ""
-	},
-	{
-		id: "haiku",
-		name: "Haiku",
-		description: ""
-	}
-];
 const THINKING_MODES = [
 	{
 		id: "off",
@@ -2818,7 +2857,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		return NO_RETRY_POLICY;
 	}
 	async listModels(provider) {
-		return MODELS.map((model) => ({
+		return latestClaudeModels().map((model) => ({
 			provider,
 			id: model.id,
 			name: model.name,
@@ -2827,8 +2866,8 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		}));
 	}
 	async resolveModel(provider, model, _signal) {
-		const known = MODELS.find((item) => item.id === model);
-		const contextWindow = this.#supervisor.contextWindow(model) ?? (known !== void 0 && "contextWindow" in known ? known.contextWindow : void 0);
+		const known = claudeModelRow(model);
+		const contextWindow = this.#supervisor.contextWindow(model) ?? known?.contextWindow;
 		return {
 			provider,
 			id: model,
@@ -4125,6 +4164,22 @@ function parseWorktreeBranches(value) {
 function slug(value, fallback) {
 	return value.toLocaleLowerCase("en-US").replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 48) || fallback;
 }
+/** A branch name as one path segment: `/` and anything else unsafe folds to
+*  `-`, case is kept so a ticket key stays scannable (`PSOS-5683`, not
+*  `psos-5683`). Flattened rather than nested on purpose -- see
+*  {@link worktreeDirectoryName}. */
+function branchSegment(branch) {
+	return branch.replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/^[-.]+/u, "").replace(/-+$/u, "").slice(0, 48).replace(/-+$/u, "") || "branch";
+}
+/** Name a worktree directory after the repository and the branch it holds, so
+*  the workspace list reads without opening a session.
+*
+*  One flat segment, never a `feature/x` subdirectory: the orphan sweep lists
+*  this root one level deep, and a prefix directory holds no lease of its own,
+*  so it would be removed along with every live worktree inside it. */
+function worktreeDirectoryName(root, branch) {
+	return `${slug(basename(root), "repository")}-${branchSegment(branch)}`;
+}
 /** Comparable form for path identity: resolved, forward slashes, case-folded
 *  so Windows drive-letter or case spelling differences cannot hide a match. */
 function comparablePath(value) {
@@ -4424,6 +4479,18 @@ var RepositorySetupService = class {
 		], root, GIT_FETCH_TIMEOUT_MS);
 		if (fetched.exitCode !== 0 || fetched.lossy) throw new RepositorySetupError("fetch-failed", "Git could not refresh remote references.");
 	}
+	/** The remote-tracking ref a local base branch follows, when that ref still
+	*  exists. Falls back to the local branch for a branch with no upstream. */
+	async #upstreamRef(git, info, branch) {
+		const upstream = await this.#run(git, [
+			"for-each-ref",
+			"--format=%(upstream:short)",
+			`refs/heads/${branch}`
+		], info.root);
+		if (upstream.exitCode !== 0 || upstream.lossy) return void 0;
+		const name = upstream.stdout.trim();
+		return name.length > 0 && info.remoteBranches.includes(name) ? `refs/remotes/${name}` : void 0;
+	}
 	async #checkout(info, branch) {
 		if (info.current !== branch) {
 			if (info.dirty) throw new RepositorySetupError("dirty-workspace", "Commit or stash workspace changes before switching branches.");
@@ -4454,10 +4521,11 @@ var RepositorySetupService = class {
 		const git = await this.#git();
 		progress("fetching");
 		await this.#fetchRemotes(git, root);
+		const startRef = reuseExistingBranch ? baseRef : await this.#upstreamRef(git, info, baseBranch) ?? baseRef;
 		const suffix = randomUUID().slice(0, 8);
 		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace(/\.\d{3}Z$/u, "Z");
 		const branch = explicitBranchName ?? await this.#generatedBranch(info, baseBranch, intent, stamp, suffix, progress);
-		const path = join(this.#worktreeRoot, `${slug(basename(root), "repository")}-${stamp}-${suffix}`);
+		const path = join(this.#worktreeRoot, await this.#freeDirectoryName(root, branch));
 		progress("creating-worktree");
 		await mkdir(this.#worktreeRoot, { recursive: true });
 		if (reuseExistingBranch) await this.#run(git, ["worktree", "prune"], root).catch(() => void 0);
@@ -4473,7 +4541,7 @@ var RepositorySetupService = class {
 			"-b",
 			branch,
 			path,
-			baseRef
+			startRef
 		], root);
 		if (created.exitCode !== 0) {
 			const detail = created.stderr.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
@@ -4520,6 +4588,21 @@ var RepositorySetupService = class {
 	/** `<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. */
+	/** The branch-named directory, or the first `-2`, `-3`, ... spelling free of
+	*  anything already on disk. Names no longer carry a timestamp, so a stale
+	*  directory a crash left behind -- or two branches that fold to the same
+	*  segment -- would otherwise fail `worktree add` outright. Compared
+	*  case-folded, since a case-insensitive filesystem would collide anyway. */
+	async #freeDirectoryName(root, branch) {
+		const base = worktreeDirectoryName(root, branch);
+		const taken = await readdir(this.#worktreeRoot).then((entries) => new Set(entries.map((entry) => entry.toLocaleLowerCase("en-US"))), () => /* @__PURE__ */ new Set());
+		if (!taken.has(base.toLocaleLowerCase("en-US"))) return base;
+		for (let index = 2; index < 100; index += 1) {
+			const candidate = `${base}-${index}`;
+			if (!taken.has(candidate.toLocaleLowerCase("en-US"))) return candidate;
+		}
+		return base;
+	}
 	async #generatedBranch(info, baseBranch, intent, stamp, suffix, progress) {
 		const prefix = safeBranch(await this.#branchPrefix());
 		if (intent !== void 0 && intent.trim().length > 0) {