@norman-else/dsh-claude 0.1.43 → 0.1.44

package/lib/index.mjs

@@ -1408,56 +1408,108 @@ 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. */
+/** The Claude Code model lineup, read from the running CLI instead of pinned
+*  here.
+*
+*  Anthropic ships models between releases of this plugin -- Fable arrived in a
+*  CLI update, not in one of ours -- so a table maintained here is stale the day
+*  it is written, and a model the user can already pick in `/model` is missing
+*  from the DSH selector until someone edits an array. The CLI answers the same
+*  question itself: every session's initialize response carries the lineup it
+*  would show in `/model`, already narrowed to the logged-in account's plan and
+*  to any `availableModels` restriction the settings cascade imposes.
+*
+*  What DSH persists on a session, though, must NOT be a CLI model id. DSH
+*  stores the selector row's id verbatim and matches it back by string
+*  equality, so a concrete id (`claude-fable-5-1[1m]`) turns into a dangling
+*  reference the moment Anthropic bumps the version -- the session keeps
+*  pointing at a row nothing advertises any more, and the composer falls back
+*  to printing the raw id. The selector therefore advertises an alias this
+*  plugin owns (`fable[1m]`), derived from the row rather than tabulated, and
+*  the CLI id it stands for is kept beside it and used only at dispatch.
+*/
+/** A 1M-context route spells it in the id (`opus[1m]`, `claude-fable-5-1[1m]`). */
+const WIDE_ROUTE = /\[1m\]$/u;
+/** What the selector shows before the lineup is known -- the probe below failed
+*  or has not answered yet. `default` is the only id that is valid on every
+*  release and plan; the rest are the stable `/model` spellings Claude Code has
+*  kept across releases, and every one of them is a spelling the CLI accepts,
+*  so a session that persists one still dispatches. */
 const SEED = [
 	{
 		id: "default",
+		value: "default",
 		name: "Default (recommended)",
 		description: ""
 	},
 	{
 		id: "opus[1m]",
+		value: "opus[1m]",
 		name: "Opus (1M context)",
 		description: "",
 		contextWindow: 1e6
 	},
 	{
 		id: "fable",
+		value: "fable",
 		name: "Fable",
 		description: ""
 	},
 	{
 		id: "sonnet",
+		value: "sonnet",
 		name: "Sonnet",
 		description: ""
 	},
 	{
 		id: "haiku",
+		value: "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. */
+/** A 1M-context route spells it in the id, 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;
+	return WIDE_ROUTE.test(row.resolvedModel ?? row.value) ? 1e6 : void 0;
+}
+/**
+* The selector id for one CLI row: the model's family, plus the `[1m]` marker
+* when the route carries one.
+*
+* Derived, never tabulated -- a family this plugin has never heard of gets its
+* id the same way, so a model Anthropic ships tomorrow lands in the selector
+* without an edit here, and a version bump (`claude-fable-5-1` ->
+* `claude-fable-5-2`) leaves an already-persisted selection pointing at the
+* same row. The family is the first non-numeric segment, which covers both
+* spellings Anthropic has used (`claude-fable-5-1`, `claude-3-5-sonnet-…`).
+*
+* Read off `value` alone, never the id it resolves to: `default` names a route
+* whose resolution moves with the account and the release, so folding the
+* resolved `[1m]` in would flip an already-persisted `default` to `default[1m]`
+* the day Anthropic repoints it.
+* @param value - the CLI's own id for the row.
+* @returns the alias to advertise.
+*/
+function claudeModelAlias(value) {
+	const wide = WIDE_ROUTE.test(value);
+	const bare = value.replace(WIDE_ROUTE, "").replace(/^claude-/u, "");
+	const family = bare.split("-").find((segment) => !/^\d+$/u.test(segment)) ?? bare;
+	return wide ? `${family}[1m]` : family;
 }
-function projectModel(row) {
+function projectModel(row, id) {
 	const contextWindow = declaredContextWindow(row);
 	return {
-		id: row.value,
+		id,
+		value: row.value,
 		name: row.displayName,
 		description: row.description,
 		...contextWindow === void 0 ? {} : { contextWindow }
 	};
 }
 let latest$1;
+let inflight;
 /**
 * Learn the lineup from one session's initialize response.
 * @param models - the CLI's own `/model` rows; an empty list is ignored so a
@@ -1465,20 +1517,96 @@ let latest$1;
 */
 function recordClaudeModels(models) {
 	if (models.length === 0) return;
-	latest$1 = models.map(projectModel);
+	const taken = /* @__PURE__ */ new Set();
+	latest$1 = models.map((row) => {
+		const alias = claudeModelAlias(row.value);
+		const id = taken.has(alias) ? row.value : alias;
+		taken.add(id);
+		return projectModel(row, id);
+	});
 }
 /** The lineup to advertise: whatever the CLI last reported, else the seed. */
 function latestClaudeModels() {
 	return latest$1 ?? SEED;
 }
+/** A throwaway probe should not outlive a wedged CLI. */
+const CLAUDE_MODEL_PROBE_TIMEOUT_MS = 2e4;
+/**
+* Read the lineup from a throwaway CLI process.
+*
+* Waiting for a session to start is too late: DSH loads the model catalog once
+* per Host generation, at connect, and does not reload it when this plugin
+* later learns the real lineup. A selector left on the seed until then hands
+* out seed ids, which is exactly how a session ends up persisting an id the
+* next launch cannot resolve. This query carries no tools, no permission
+* bridge and no session binding: it starts, reports what `/model` would show,
+* and is killed -- no prompt is ever sent, so it costs no tokens.
+* @param executablePath - the resolved CLI, or '' to let the SDK find it.
+* @param factory - test seam for the SDK query.
+* @returns the CLI's own `/model` rows.
+*/
+async function probeClaudeModels(executablePath, factory = query) {
+	const lifetime = new AbortController();
+	const timer = setTimeout(() => lifetime.abort(), CLAUDE_MODEL_PROBE_TIMEOUT_MS);
+	timer.unref?.();
+	const query$2 = factory({
+		prompt: (async function* () {
+			await new Promise(() => {});
+		})(),
+		options: {
+			cwd: process.cwd(),
+			abortController: lifetime,
+			...executablePath.length === 0 ? {} : { pathToClaudeCodeExecutable: executablePath }
+		}
+	});
+	try {
+		(async () => {
+			for await (const _ of query$2);
+		})().catch(() => void 0);
+		return (await Promise.race([query$2.initializationResult(), new Promise((_resolve, reject) => {
+			setTimeout(() => reject(/* @__PURE__ */ new Error("dsh-claude: the model lineup probe did not answer in time")), CLAUDE_MODEL_PROBE_TIMEOUT_MS).unref?.();
+		})])).models;
+	} finally {
+		clearTimeout(timer);
+		lifetime.abort();
+	}
+}
+/**
+* The lineup, learning it from the CLI the first time DSH asks for the catalog.
+* @param probe - reads the CLI's rows; a failure leaves the seed in place and
+*   is retried on the next catalog load.
+* @returns the rows to advertise, never rejecting.
+*/
+function ensureClaudeModels(probe) {
+	if (latest$1 !== void 0) return Promise.resolve(latest$1);
+	inflight ??= probe().then((models) => {
+		recordClaudeModels(models);
+	}).catch(() => void 0).then(() => {
+		inflight = void 0;
+		return latestClaudeModels();
+	});
+	return inflight;
+}
 /**
 * Look one id up in the current lineup.
-* @param id - the id DSH persisted on the session, which may name a model the
+* @param id - the id DSH persisted on the session, which may be an alias, a
+*   concrete CLI id persisted before this plugin aliased anything, or a row 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);
+	const rows = latestClaudeModels();
+	return rows.find((row) => row.id === id) ?? rows.find((row) => row.value === id) ?? rows.find((row) => row.id === claudeModelAlias(id));
+}
+/**
+* The spelling to hand the CLI for one selector id.
+* @param id - the id DSH persisted on the session.
+* @returns the CLI's own id, or the selector id itself when the lineup does not
+*   cover it -- the seed vocabulary is made of spellings the CLI accepts, and a
+*   session persisted before this plugin aliased anything already holds one.
+*/
+function claudeModelValue(id) {
+	return claudeModelRow(id)?.value ?? id;
 }
 //#endregion
 //#region src/plan-usage.ts
@@ -2478,7 +2606,7 @@ var ClaudeSupervisor = class {
 				resume: binding.claudeSessionId,
 				...forkAt === void 0 ? {} : { resumeSessionAt: forkAt }
 			},
-			model,
+			model: claudeModelValue(model),
 			...thinkingMode === void 0 ? {} : thinkingMode === "off" ? { thinking: { type: "disabled" } } : thinkingMode === "ultracode" ? { settings: { ultracode: true } } : { effort: thinkingMode }
 		};
 		entry.query = this.#queryFactory({
@@ -3527,7 +3655,10 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 	*  Settings dialog, and the read is dwarfed by the process the turn spawns. */
 	#renderMode;
 	#summarizeTitle;
-	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request)) {
+	/** Reads the CLI's own `/model` rows, so the selector never has to advertise
+	*  the seed vocabulary once the CLI can answer for itself. */
+	#probeModels;
+	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request), probeModels = async () => []) {
 		super();
 		this.#supervisor = supervisor;
 		this.#agents = agents;
@@ -3536,6 +3667,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		this.#drainReviewComments = drainReviewComments;
 		this.#renderMode = renderMode;
 		this.#summarizeTitle = summarizeTitle;
+		this.#probeModels = probeModels;
 	}
 	providerInfo(provider) {
 		return {
@@ -3547,7 +3679,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		return NO_RETRY_POLICY;
 	}
 	async listModels(provider) {
-		return latestClaudeModels().map((model) => ({
+		return (await ensureClaudeModels(this.#probeModels)).map((model) => ({
 			provider,
 			id: model.id,
 			name: model.name,
@@ -3748,8 +3880,8 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		if (!completed) throw new Error("dsh-claude: Claude turn stream ended without a result");
 	}
 };
-function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request)) {
-	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode, summarizeTitle);
+function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request), probeModels = async () => []) {
+	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode, summarizeTitle, probeModels);
 }
 //#endregion
 //#region src/plugin-budget.ts
@@ -4314,6 +4446,82 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 	});
 }
 //#endregion
+//#region src/diff-funcname.ts
+/** Extensions mapped onto a funcname driver, so `@@` hunk headers name the
+*  method a change sits in. Without one git falls back to "the last line that
+*  starts in column 0", which in Java or Kotlin is always the class. */
+const DIFF_ATTRIBUTES = [
+	"*.java diff=java",
+	"*.kt diff=kotlin",
+	"*.kts diff=kotlin",
+	"*.py diff=python",
+	"*.pyi diff=python",
+	"*.js diff=dshweb",
+	"*.jsx diff=dshweb",
+	"*.mjs diff=dshweb",
+	"*.cjs diff=dshweb",
+	"*.ts diff=dshweb",
+	"*.tsx diff=dshweb",
+	"*.mts diff=dshweb",
+	"*.cts diff=dshweb",
+	"*.vue diff=dshweb",
+	"*.svelte diff=dshweb",
+	"*.css diff=css",
+	"*.scss diff=css",
+	"*.less diff=css",
+	""
+].join("\n");
+/** git ships no JavaScript driver, so this is the one pattern we write ourselves.
+*
+*  POSIX extended regexes, one per line, matched top-down: a leading `!` marks a
+*  line that can never be a header, and the reported text is capture group 1 --
+*  hence the outer parentheses around everything worth showing.
+*
+*  Line 2 keeps git's own fallback (anything unindented), because a driver
+*  replaces that fallback rather than extending it, and most of a frontend file's
+*  declarations already live in column 0. Lines 3 and 4 add what the fallback
+*  cannot see: nested declarations, and indented class or object methods.
+*
+*  ponytail: a method line must end in `{`. Allowing `)` too would pick up every
+*  bare `foo(bar)` statement, which reads as a header and hides the real one.
+*/
+const DSHWEB_FUNCNAME = [
+	"!^[ 	]*(if|else|for|while|do|switch|case|catch|try|finally|return|await|new|throw|typeof)[^A-Za-z0-9_$]",
+	"^([A-Za-z_$].*)$",
+	"^[ 	]*((export[ 	]+)?(default[ 	]+)?(declare[ 	]+)?(abstract[ 	]+)?(async[ 	]+)?(function|class|interface|enum|namespace|module)[ 	].*)$",
+	"^[ 	]*(((public|private|protected|static|readonly|abstract|async|get|set)[ 	]+)*[A-Za-z_$#][A-Za-z0-9_$]*[ 	]*[:=]?[ 	]*(async[ 	]+)?[(<][^;]*\\{)[ 	]*$"
+].join("\n");
+let attributesFile;
+async function writeAttributes() {
+	const path = dshHomePath("plugins", "dsh-claude", "diff-attributes");
+	try {
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, DIFF_ATTRIBUTES, "utf8");
+		return path;
+	} catch {
+		return;
+	}
+}
+/** `-c` overrides to place in front of a `git diff`, teaching it which funcname
+*  driver each extension uses.
+*
+*  `core.attributesFile` is the lowest-precedence attribute source, so a
+*  repository that already declares its own `.gitattributes` still wins. Better
+*  hunk headers are cosmetic: a failed write drops the overrides and the diff
+*  runs exactly as before.
+*/
+async function diffFuncnameArgs() {
+	attributesFile ??= writeAttributes();
+	const path = await attributesFile;
+	if (path === void 0) return [];
+	return [
+		"-c",
+		`core.attributesFile=${path}`,
+		"-c",
+		`diff.dshweb.xfuncname=${DSHWEB_FUNCNAME}`
+	];
+}
+//#endregion
 //#region src/repository-status.ts
 const MAX_OUTPUT_BYTES$4 = 65536;
 const MAX_DIFF_BYTES = 262144;
@@ -4707,6 +4915,7 @@ var RepositoryStatusService = class {
 			if (numstat.exitCode !== 0 || numstat.lossy) return void 0;
 			const summary = parseDiffNumstat(numstat.stdout);
 			const patch = await run(this.#runtime, git, [
+				...await diffFuncnameArgs(),
 				"diff",
 				"--no-ext-diff",
 				"--no-color",
@@ -5851,6 +6060,7 @@ var RepositoryActionService = class {
 			"--path-format=absolute",
 			"--show-toplevel"
 		], cwd, GIT_TIMEOUT_MS$1, "not-repository", "The session directory is not a Git repository.")).stdout.trim();
+		const funcname = await diffFuncnameArgs();
 		const [branchResult, headResult, statusResult, stagedPatch, unstagedPatch] = await Promise.all([
 			this.#run(git, [
 				"symbolic-ref",
@@ -5866,6 +6076,7 @@ var RepositoryActionService = class {
 				"--untracked-files=all"
 			], root, GIT_TIMEOUT_MS$1),
 			this.#run(git, [
+				...funcname,
 				"diff",
 				"--cached",
 				"--no-ext-diff",
@@ -5876,6 +6087,7 @@ var RepositoryActionService = class {
 				":(exclude)**/WARP.md"
 			], root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$2),
 			this.#run(git, [
+				...funcname,
 				"diff",
 				"--no-ext-diff",
 				"--no-color",
@@ -9232,7 +9444,7 @@ async function apply(ctx, config) {
 	let resolutionError;
 	try {
 		supervisorConfig.executablePath = (await resolveClaudeExecutable(ctx.subprocess, config.executablePath === void 0 || config.executablePath.length === 0 ? void 0 : config.executablePath)).path;
-		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => readRenderMode(), (request) => summarizeSessionTitle(supervisorConfig.executablePath, request)));
+		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => readRenderMode(), (request) => summarizeSessionTitle(supervisorConfig.executablePath, request), () => probeClaudeModels(supervisorConfig.executablePath)));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
 			const pending = /* @__PURE__ */ new Set();
@@ -9361,7 +9573,7 @@ async function apply(ctx, config) {
 		registerAskRoute(webCtx, new AskService(webCtx.subprocess, supervisorConfig.executablePath), cwdForClaudeSession, (sessionId) => {
 			const snapshot = supervisor.snapshots().find((item) => item.sessionId === sessionId);
 			return snapshot === void 0 ? void 0 : {
-				model: snapshot.model,
+				model: claudeModelValue(snapshot.model),
 				...snapshot.thinkingMode === void 0 ? {} : { thinkingMode: snapshot.thinkingMode }
 			};
 		});