@norman-else/dsh-claude 0.1.51 → 0.1.53

package/lib/index.mjs

@@ -3478,13 +3478,17 @@ async function summarizeSessionTitle(executablePath, request, factory = query) {
 				abortController: lifetime,
 				model: SESSION_TITLE_MODEL,
 				allowedTools: [],
-				settingSources: [],
+				settingSources: [
+					"user",
+					"project",
+					"local"
+				],
 				maxTurns: 1,
 				...executablePath.length === 0 ? {} : { pathToClaudeCodeExecutable: executablePath }
 			}
 		});
 		for await (const message of query) {
-			if (message.type !== "result" || message.subtype !== "success") continue;
+			if (message.type !== "result" || message.subtype !== "success" || message.is_error === true) continue;
 			const title = sessionTitleLine(message.result);
 			if (title.length > 0) return title;
 			break;
@@ -5214,9 +5218,8 @@ function uniqueBranchName(candidate, taken) {
 /** 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. */
+*  plan-usage probe: there is no session to borrow yet. Settings sources match
+*  conversation turns so the CLI can resolve settings-based authentication. */
 async function summarizeBranchSlug(executablePath, intent, factory = query) {
 	const task = intent.trim().slice(0, MAX_INTENT_CHARS);
 	if (task.length === 0) return void 0;
@@ -5231,12 +5234,16 @@ async function summarizeBranchSlug(executablePath, intent, factory = query) {
 				abortController: lifetime,
 				model: BRANCH_SUMMARY_MODEL,
 				allowedTools: [],
-				settingSources: [],
+				settingSources: [
+					"user",
+					"project",
+					"local"
+				],
 				maxTurns: 1,
 				...executablePath.length === 0 ? {} : { pathToClaudeCodeExecutable: executablePath }
 			}
 		});
-		for await (const message of query) if (message.type === "result" && message.subtype === "success") return branchSlug(message.result);
+		for await (const message of query) if (message.type === "result" && message.subtype === "success" && message.is_error !== true) return branchSlug(message.result);
 		return;
 	} catch {
 		return;
@@ -5407,9 +5414,10 @@ var RepositorySetupService = class {
 		progress("switching-branch");
 		return !local && remote ? this.#checkoutRemote(info, branch) : this.#checkout(info, branch);
 	}
-	/** Tear down a merged branch: remove a plugin worktree (and its lease and
-	*  branch), or switch a plain checkout back to the base branch and delete
-	*  the merged branch. Refuses dirty trees. */
+	/** Tear down a merged branch: remove a worktree (a plugin one with its
+	*  lease, or one another tool added) and its branch, or switch a plain
+	*  checkout back to the base branch and delete the merged branch. Refuses
+	*  dirty trees. */
 	/** `branch` names the merged branch when the checkout is no longer on it:
 	*  a session that opened a pull request in another clone switched that
 	*  clone back to base itself, and only the local branch is left to delete.
@@ -5453,6 +5461,42 @@ var RepositorySetupService = class {
 				};
 			});
 		}
+		const dirs = await this.#run(git, [
+			"rev-parse",
+			"--path-format=absolute",
+			"--git-dir",
+			"--git-common-dir"
+		], path);
+		const [gitDir = "", commonDir = ""] = dirs.exitCode === 0 ? dirs.stdout.trim().split(/\r?\n/u) : [];
+		if (gitDir.length > 0 && comparablePath(gitDir) !== comparablePath(commonDir)) {
+			const mainRoot = resolve(commonDir, "..");
+			const head = named === void 0 ? await this.#run(git, [
+				"symbolic-ref",
+				"--quiet",
+				"--short",
+				"HEAD"
+			], path) : void 0;
+			const branch = named ?? (head?.exitCode === 0 ? head.stdout.trim() : "");
+			if (branch.length === 0) throw new RepositorySetupError("nothing-to-clean", "The worktree is not on a branch.");
+			if (requirePushed) await this.#requirePushed(git, mainRoot, branch);
+			if ((await this.#run(git, [
+				"worktree",
+				"remove",
+				"--",
+				path
+			], mainRoot)).exitCode !== 0) throw new RepositorySetupError("worktree-remove-failed", "Git could not remove the worktree.");
+			await this.#run(git, [
+				"branch",
+				"-D",
+				"--",
+				branch
+			], mainRoot).catch(() => void 0);
+			return {
+				mode: "worktree",
+				root: mainRoot,
+				branch
+			};
+		}
 		const root = await this.#repositoryRoot(git, path);
 		if (base === void 0) throw new RepositorySetupError("nothing-to-clean", "A plain checkout needs the base branch to return to.");
 		const head = await this.#run(git, [
@@ -5849,9 +5893,19 @@ var RepositorySetupService = class {
 //#region src/repository-actions.ts
 const MAX_OUTPUT_BYTES$1 = 262144;
 const MAX_PATCH_CHARS = 65536;
-const MAX_MESSAGE_CHARS = 512;
+const MAX_MESSAGE_CHARS = 2048;
 const MAX_PR_TEXT_CHARS = 8192;
 const MAX_UNPUSHED_COMMITS = 20;
+/** What one generation shows the model: the whole patch when it fits, the
+*  head of it otherwise, and the prompt says which. */
+const MAX_GENERATE_PATCH_CHARS = 49152;
+const MAX_SUBJECT_CHARS = 72;
+/** Past this the first line is not a subject at all; under it, a subject a
+*  few characters over what the prompt asked for is the user's to trim. */
+const MAX_SUBJECT_KEPT_CHARS = 120;
+const MAX_PR_TITLE_CHARS = 100;
+const MAX_RECENT_SUBJECTS = 10;
+const MAX_PR_COMMITS = 50;
 const GIT_TIMEOUT_MS$1 = 15e3;
 const REMOTE_TIMEOUT_MS = 6e4;
 const GENERATE_TIMEOUT_MS = 6e4;
@@ -5859,10 +5913,19 @@ const GENERATE_TIMEOUT_MS = 6e4;
 *  use is cost: MCP servers (which `ask` already skips for the same reason,
 *  and which stall for as long as an unreachable one takes to give up) and the
 *  user's own hooks and settings. Project settings stay: a repository's commit
-*  conventions belong in the message. `--tools ''` keeps `--output-format`
-*  between it and the prompt -- both flags are variadic. */
+*  conventions belong in the message. The prompt itself goes in on stdin:
+*  a 48 KB diff on argv is past what Windows lets a process be started with
+*  (ENAMETOOLONG, and the fallback subject where a message should be).
+*
+*  Sonnet rather than the session's default: describing a diff needs no
+*  frontier model, but telling three unrelated changes apart in one diff is
+*  where haiku starts to blur them, and sonnet costs only a second or two
+*  more. Extended thinking is off (see {@link GENERATE_ENV}): the naming call
+*  in prompts.ts measured it as most of a ten-second run. */
 const GENERATE_ARGUMENTS = [
 	"-p",
+	"--model",
+	"sonnet",
 	"--strict-mcp-config",
 	"--mcp-config",
 	"{\"mcpServers\":{}}",
@@ -5873,6 +5936,8 @@ const GENERATE_ARGUMENTS = [
 	"--output-format",
 	"text"
 ];
+/** A CLI that stops honouring the variable is slow again, never wrong. */
+const GENERATE_ENV = { MAX_THINKING_TOKENS: "0" };
 var RepositoryActionError = class extends Error {
 	code;
 	commit;
@@ -5932,11 +5997,82 @@ function fallbackCommitMessage(files) {
 	if (files.length === 1) return `Update ${files[0]?.path ?? "repository files"}`;
 	return `Update ${files.length} repository files`;
 }
-function normalizedGeneratedMessage(value, fallback) {
-	const first = value.split(/\r?\n/u).map((line) => line.trim()).find(Boolean);
-	if (first === void 0) return fallback;
-	const message = first.replace(/^['"`]+|['"`]+$/gu, "").replace(/[\0\r\n]/gu, " ").trim();
-	return message.length === 0 || message.length > 72 ? fallback : message;
+/** The model's answer as lines: fences and a trailing prose apology dropped,
+*  carriage returns and NULs (which git and the request validator refuse)
+*  gone, leading blank lines gone. */
+function answerLines(value) {
+	const kept = value.replace(/\0/gu, "").split(/\r?\n/u).map((line) => line.trimEnd()).filter((line) => !line.trim().startsWith("```"));
+	while (kept.length > 0 && kept[0]?.trim() === "") kept.shift();
+	while (kept.length > 0 && kept.at(-1)?.trim() === "") kept.pop();
+	return kept;
+}
+function unquoted(line) {
+	return line.trim().replace(/^['"`]+|['"`]+$/gu, "").trim();
+}
+/** Subject line, then a body when the model wrote one: the subject must at
+*  least look like one, the body is kept as the bullets the model listed, and the
+*  whole thing is cut at a line boundary under the commit-message cap. */
+function normalizeCommitMessage(value, fallback) {
+	const lines = answerLines(value);
+	const subject = unquoted(lines[0] ?? "");
+	if (subject.length === 0 || subject.length > MAX_SUBJECT_KEPT_CHARS) return fallback;
+	const body = lines.slice(1);
+	while (body.length > 0 && body[0]?.trim() === "") body.shift();
+	const kept = [subject];
+	if (body.length > 0) kept.push("");
+	let previousBlank = false;
+	for (const line of body) {
+		const blank = line.trim() === "";
+		if (blank && previousBlank) continue;
+		previousBlank = blank;
+		if ([...kept, line].join("\n").length > MAX_MESSAGE_CHARS) break;
+		kept.push(line);
+	}
+	while (kept.length > 1 && kept.at(-1)?.trim() === "") kept.pop();
+	return kept.join("\n");
+}
+/** `Title:` on its own line, then the `Summary:` / `Changes:` body the
+*  create-pr arm insists on. Anything else is the caller's fallback. */
+function parsePullRequestText(value) {
+	const lines = answerLines(value);
+	const titleAt = lines.findIndex((line) => /^title:/iu.test(line.trim()));
+	if (titleAt < 0) return void 0;
+	const title = unquoted(lines[titleAt].trim().replace(/^title:/iu, ""));
+	if (title.length === 0 || title.length > MAX_PR_TITLE_CHARS) return void 0;
+	const summaryAt = lines.findIndex((line, index) => index > titleAt && /^summary:/iu.test(line.trim()));
+	if (summaryAt < 0) return void 0;
+	const body = lines.slice(summaryAt).map((line) => line.trim() === "" ? "" : line).join("\n").trim();
+	return validPullRequestBody(body) && body.length <= MAX_PR_TEXT_CHARS ? {
+		title,
+		body
+	} : void 0;
+}
+function fallbackPullRequestText(commits, files) {
+	const title = commits[0]?.subject ?? fallbackCommitMessage(files);
+	const changes = commits.length > 0 ? commits.map((commit) => commit.subject) : files.map((file) => `Update ${file.path}`);
+	return {
+		title,
+		body: `Summary: ${title}\n\nChanges:\n${(changes.length > 0 ? changes : [title]).map((item) => `- ${item}`).join("\n")}`
+	};
+}
+function parseBranchCommits(output) {
+	return output.split("\0").flatMap((record) => {
+		const [subject = "", ...rest] = record.replace(/^\r?\n/u, "").split(/\r?\n/u);
+		if (subject.trim().length === 0) return [];
+		return [{
+			subject: subject.trim().slice(0, 140),
+			body: rest.join("\n").trim()
+		}];
+	}).slice(0, MAX_PR_COMMITS);
+}
+function boundedPatch(patch) {
+	return patch.length > MAX_GENERATE_PATCH_CHARS ? {
+		text: patch.slice(0, MAX_GENERATE_PATCH_CHARS),
+		truncated: true
+	} : {
+		text: patch,
+		truncated: false
+	};
 }
 function validPrUrl(value) {
 	try {
@@ -5973,19 +6109,126 @@ var RepositoryActionService = class {
 		const preview = await this.#preview(cwd);
 		if (preview.fingerprint !== fingerprint) throw new RepositoryActionError("repository-changed", "Repository changes have changed. Refresh the commit panel.");
 		const fallback = fallbackCommitMessage(preview.files);
+		const git = await this.#git();
+		const recent = await this.#run(git, [
+			"log",
+			"--no-merges",
+			"--format=%s",
+			"-n",
+			String(MAX_RECENT_SUBJECTS),
+			"HEAD",
+			"--"
+		], preview.root, GIT_TIMEOUT_MS$1);
+		const subjects = recent.exitCode === 0 && !recent.lossy ? recent.stdout.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0) : [];
+		const patch = boundedPatch(preview.patch);
 		const prompt = [
-			"Write one concise English git commit subject (imperative mood, maximum 72 characters).",
-			"Return only the subject without quotes, markdown, body, or explanation.",
+			"Write a git commit message for the changes below, in English.",
+			`Line 1 is the subject: imperative mood, at most ${MAX_SUBJECT_CHARS} characters, saying what the change does rather than which files it touches.`,
+			"If the diff contains more than one independent change, leave line 2 blank and then list each change on its own line starting with \"- \", one sentence each, describing what changed as the diff shows it.",
+			"A change with a single purpose gets the subject line only.",
+			"Describe only what the diff shows. Do not invent motivation, do not summarise the file list, and do not mention that the diff is truncated.",
+			"Return only the message: no quotes, no markdown fences, no explanation before or after it.",
+			...subjects.length > 0 ? [`Recent commit subjects of this repository, as a style reference only:\n${subjects.map((subject) => `- ${subject}`).join("\n")}`] : [],
 			`Files: ${preview.files.map((file) => file.path).join(", ")}`,
-			`Diff:\n${preview.patch.slice(0, 24576)}`
+			...patch.truncated || preview.truncated ? ["The diff below is cut short; the file list above is complete."] : [],
+			`Diff:\n${patch.text}`
 		].join("\n");
 		try {
-			const result = await this.#run(this.#claudeExecutable, GENERATE_ARGUMENTS.concat(prompt), preview.root, GENERATE_TIMEOUT_MS);
-			return result.exitCode === 0 && !result.lossy ? normalizedGeneratedMessage(result.stdout, fallback) : fallback;
+			const result = await this.#run(this.#claudeExecutable, GENERATE_ARGUMENTS, preview.root, GENERATE_TIMEOUT_MS, MAX_OUTPUT_BYTES$1, GENERATE_ENV, prompt);
+			return result.exitCode === 0 && !result.lossy ? normalizeCommitMessage(result.stdout, fallback) : fallback;
 		} catch {
 			return fallback;
 		}
 	}
+	/** Title and description for the pull request the branch would open: the
+	*  commits and diff since the base, plus whatever is still uncommitted,
+	*  since create-pr commits that first. Base is the named branch on origin,
+	*  else origin's default; with neither, the tree alone. */
+	async generatePullRequest(cwd, fingerprint, baseBranch) {
+		const preview = await this.#preview(cwd);
+		if (preview.fingerprint !== fingerprint) throw new RepositoryActionError("repository-changed", "Repository changes have changed. Refresh the commit panel.");
+		const git = await this.#git();
+		const base = await this.#baseRef(git, preview.root, baseBranch);
+		let commits = [];
+		let branchPatch = "";
+		let branchTruncated = false;
+		if (base !== void 0) {
+			const log = await this.#run(git, [
+				"log",
+				"--no-merges",
+				"--format=%s%n%b%x00",
+				"-n",
+				String(51),
+				`${base}..HEAD`,
+				"--"
+			], preview.root, GIT_TIMEOUT_MS$1);
+			if (log.exitCode === 0 && !log.lossy) commits = parseBranchCommits(log.stdout);
+			const funcname = await diffFuncnameArgs();
+			const diff = await this.#run(git, [
+				...funcname,
+				"diff",
+				"--no-ext-diff",
+				"--no-color",
+				"--unified=3",
+				`${base}...HEAD`,
+				"--",
+				":(exclude)WARP.md",
+				":(exclude)**/WARP.md"
+			], preview.root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$1);
+			if (diff.exitCode === 0) {
+				branchPatch = diff.stdout;
+				branchTruncated = diff.lossy;
+			}
+		}
+		const fallback = fallbackPullRequestText(commits, preview.files);
+		const patch = boundedPatch([branchPatch, preview.patch].filter((part) => part.length > 0).join("\n"));
+		const prompt = [
+			"Write the title and description of a GitHub pull request for the changes below, in English.",
+			"Answer in exactly this shape and nothing else:",
+			`Title: <imperative title, at most ${MAX_SUBJECT_CHARS} characters, saying what the pull request does>`,
+			"Summary: <one sentence saying what the pull request achieves as a whole>",
+			"",
+			"Changes:",
+			"- <one line per independent change, describing what changed in the code>",
+			"",
+			"List every independent change the diff contains as its own bullet. Do not merge unrelated changes into one bullet, and do not describe anything the diff does not show.",
+			"No markdown headings, no quotes, no fences, no text before \"Title:\" or after the last bullet.",
+			...commits.length > 0 ? [`Commits on this branch, newest first:\n${commits.map((commit) => commit.body.length > 0 ? `- ${commit.subject}\n${commit.body}` : `- ${commit.subject}`).join("\n")}`] : [],
+			...preview.files.length > 0 ? [`Uncommitted files that will go into the same pull request: ${preview.files.map((file) => file.path).join(", ")}`] : [],
+			...patch.truncated || branchTruncated || preview.truncated ? ["The diff below is cut short; the commit list is complete."] : [],
+			`Diff:\n${patch.text}`
+		].join("\n");
+		try {
+			const result = await this.#run(this.#claudeExecutable, GENERATE_ARGUMENTS, preview.root, GENERATE_TIMEOUT_MS, MAX_OUTPUT_BYTES$1, GENERATE_ENV, prompt);
+			return (result.exitCode === 0 && !result.lossy ? parsePullRequestText(result.stdout) : void 0) ?? fallback;
+		} catch {
+			return fallback;
+		}
+	}
+	/** `origin/<branch>` when the named branch exists on origin, else the branch
+	*  origin's HEAD points at. Neither on a checkout that never fetched. */
+	async #baseRef(git, root, baseBranch) {
+		const named = baseBranch?.trim() ?? "";
+		if (named.length > 0) {
+			if (/[\0\r\n\s]|\.\.|^-/u.test(named)) return void 0;
+			const verified = await this.#run(git, [
+				"rev-parse",
+				"--verify",
+				"--quiet",
+				"--symbolic-full-name",
+				`refs/remotes/origin/${named}`
+			], root, GIT_TIMEOUT_MS$1);
+			return verified.exitCode === 0 && !verified.lossy && verified.stdout.trim() === `refs/remotes/origin/${named}` ? `origin/${named}` : void 0;
+		}
+		const head = await this.#run(git, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"refs/remotes/origin/HEAD"
+		], root, GIT_TIMEOUT_MS$1);
+		const ref = head.stdout.trim();
+		return head.exitCode === 0 && !head.lossy && /^origin\/[^\s]+$/u.test(ref) ? ref : void 0;
+	}
 	execute(cwd, request) {
 		const operation = this.#pending.then(() => this.#execute(cwd, request));
 		this.#pending = operation.then(() => void 0, () => void 0);
@@ -6378,18 +6621,18 @@ var RepositoryActionService = class {
 		if (result.exitCode !== 0 || result.lossy) throw new RepositoryActionError(code, message);
 		return result;
 	}
-	#run(executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$1) {
+	#run(executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$1, env = {}, stdin) {
 		return collect$1(this.#runtime.spawn({
 			argv: [executable, ...args],
 			cwd,
 			stdio: {
-				stdin: "ignore",
+				stdin: stdin === void 0 ? "ignore" : { data: stdin },
 				stdout: { maxBytes },
 				stderr: { maxBytes: MAX_OUTPUT_BYTES$1 }
 			},
 			graceMs: 1e3,
 			signal: AbortSignal.timeout(timeoutMs),
-			env: {}
+			env
 		}));
 	}
 };
@@ -6648,6 +6891,17 @@ function registerRepositoryActionRoute(ctx, service, cwdForSession) {
 						value: { message: await service.generateMessage(cwd, string$1(input, "fingerprint")) }
 					};
 				}
+				if (url.pathname === `/plugins/dsh-claude/repository/action/pull-request`) {
+					if (io.method !== "POST") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					const input = await readJson$5(io);
+					return {
+						status: 200,
+						value: await service.generatePullRequest(cwd, string$1(input, "fingerprint"), optionalString(input, "baseBranch"))
+					};
+				}
 				if (url.pathname === "/plugins/dsh-claude/repository/action") {
 					if (io.method !== "POST") return {
 						status: 405,
@@ -8762,6 +9016,13 @@ async function isDirectory(path) {
 }
 /** Repository roots behind the touched paths, minus the session's own, in
 *  first-seen order. `rootOf` answers undefined outside any repository. */
+/** Whether `child` lies strictly under `parent`. Compared with one separator:
+*  on Windows git prints forward slashes where Node resolves to backslashes,
+*  and a root can arrive in either form. */
+function isInside(child, parent) {
+	const slashed = (value) => value.replaceAll("\\", "/").replace(/\/+$/u, "");
+	return slashed(child).startsWith(`${slashed(parent)}/`);
+}
 async function touchedRepositoryRoots(paths, sessionRoot, rootOf, max, directory = isDirectory) {
 	const roots = [];
 	const directories = /* @__PURE__ */ new Set();
@@ -8769,7 +9030,7 @@ async function touchedRepositoryRoots(paths, sessionRoot, rootOf, max, directory
 	for (const directory of directories) {
 		const root = await rootOf(directory);
 		if (root === void 0 || root === sessionRoot || roots.includes(root)) continue;
-		if (sessionRoot.startsWith(root.endsWith(sep) ? root : root + sep)) continue;
+		if (isInside(sessionRoot, root)) continue;
 		roots.push(root);
 		if (roots.length >= max) break;
 	}