@klarkxy/dsh-git-commit 0.1.3

package/lib/index.js

@@ -0,0 +1,846 @@
+import { DEFAULT_MAX_OUTPUT_TOKENS, MAX_MANIFEST_CHARS, MAX_UNTRACKED_PREVIEW_CHARS, PLUGIN_NAME, PROMPT_VERSION, PURPOSE_ID, RPC_CHANNEL, SCHEMA_VERSION } from "./contracts.js";
+import { registerHostRpc } from "@klarkxy/dsh-ai-services/host-rpc";
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { copyFile, lstat, mkdtemp, open, readFile, readlink, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
+//#region src/git.ts
+var GitError = class extends Error {
+	stderr;
+	constructor(message, stderr = "") {
+		super(message);
+		this.name = "GitError";
+		this.stderr = stderr;
+	}
+};
+/** NUL separator used by `git status -z` without embedding a control byte in this source file. */
+const NUL = String.fromCharCode(0);
+/** Spawn git without a shell; arguments are passed literally. */
+const execGit = (args, options) => new Promise((resolve, reject) => {
+	try {
+		execFile("git", [...args], {
+			cwd: options.cwd,
+			encoding: "utf8",
+			maxBuffer: 33554432,
+			timeout: options.timeoutMs ?? 3e4,
+			signal: options.signal,
+			windowsHide: true,
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0",
+				GIT_LITERAL_PATHSPECS: "1"
+			}
+		}, (error, stdout, stderr) => {
+			if (error) {
+				if (options.signal?.aborted) {
+					reject(Object.assign(/* @__PURE__ */ new Error("dsh-git-commit: git command cancelled"), { code: "cancelled" }));
+					return;
+				}
+				reject(Object.assign(new GitError(stderr.trim() || error.message, stderr), { code: error.code }));
+				return;
+			}
+			resolve(stdout);
+		});
+	} catch (error) {
+		reject(error);
+	}
+});
+function isGitMissing(error) {
+	return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function statusLetter(kind) {
+	switch (kind) {
+		case "added": return "A";
+		case "deleted": return "D";
+		case "renamed": return "R";
+		case "copied": return "C";
+		case "untracked": return "?";
+		default: return "M";
+	}
+}
+/**
+* Parse `git status --porcelain=v1 -z --untracked-files=all` output.
+* In -z mode rename/copy entries put the destination path first, then a NUL, then the origin path.
+*/
+function parsePorcelain(output) {
+	const tokens = output.split(NUL);
+	const files = [];
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		index += 1;
+		if (!token) continue;
+		if (token.length < 4) continue;
+		const x = token[0] ?? " ";
+		const y = token[1] ?? " ";
+		const path = token.slice(3);
+		if (x === "!" && y === "!") continue;
+		if (x === "?" && y === "?") {
+			files.push({
+				path,
+				status: "untracked",
+				staged: false
+			});
+			continue;
+		}
+		if (x === "R" || x === "C" || y === "R" || y === "C") {
+			const origin = tokens[index];
+			index += 1;
+			if (!origin) throw new GitError("dsh-git-commit: incomplete rename status");
+			files.push({
+				path,
+				origin,
+				status: x === "C" || y === "C" ? "copied" : "renamed",
+				staged: x !== " " && x !== "?"
+			});
+			continue;
+		}
+		if (x === "U" || y === "U" || x === "A" && y === "A" || x === "D" && y === "D") throw new GitError(`dsh-git-commit: resolve merge conflicts before committing (${path})`);
+		const status = x === "D" || y === "D" ? "deleted" : x === "A" || y === "A" ? "added" : "modified";
+		files.push({
+			path,
+			status,
+			staged: x !== " " && x !== "?"
+		});
+	}
+	return files;
+}
+async function repoInfo(run, cwd, signal) {
+	const root = (await run(["rev-parse", "--show-toplevel"], {
+		cwd,
+		signal
+	})).trim();
+	let branch = (await run([
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"HEAD"
+	], {
+		cwd: root,
+		signal
+	}).catch(() => "")).trim();
+	if (!branch) branch = (await run([
+		"rev-parse",
+		"--short",
+		"HEAD"
+	], {
+		cwd: root,
+		signal
+	}).catch(() => "")).trim();
+	return {
+		root,
+		branch: branch || "HEAD"
+	};
+}
+async function workingTreeChanges(run, root, signal) {
+	return parsePorcelain(await run([
+		"status",
+		"--porcelain=v1",
+		"-z",
+		"--untracked-files=all"
+	], {
+		cwd: root,
+		signal
+	}));
+}
+/** Exact index/worktree content fingerprint, including untracked file bytes. */
+async function workspaceSnapshot(run, root, signal) {
+	const status = await run([
+		"status",
+		"--porcelain=v1",
+		"-z",
+		"--untracked-files=all"
+	], {
+		cwd: root,
+		signal
+	});
+	const files = parsePorcelain(status);
+	const hash = createHash("sha256").update(status);
+	hash.update(await run([
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	], {
+		cwd: root,
+		signal
+	}).catch(() => "DETACHED"));
+	hash.update(await run(["rev-parse", "HEAD"], {
+		cwd: root,
+		signal
+	}).catch(() => "unborn"));
+	hash.update(await run([
+		"diff",
+		"--cached",
+		"--binary",
+		"--no-ext-diff"
+	], {
+		cwd: root,
+		signal
+	}));
+	hash.update(await run([
+		"diff",
+		"--binary",
+		"--no-ext-diff"
+	], {
+		cwd: root,
+		signal
+	}));
+	for (const file of files) {
+		if (file.status !== "untracked") continue;
+		hash.update(file.path);
+		hash.update(await worktreePathDigest(run, root, file.path, signal));
+	}
+	return {
+		files,
+		fingerprint: hash.digest("hex")
+	};
+}
+/** A worktree content check for groups waiting behind earlier commits. */
+async function pathVersions(run, root, paths, signal) {
+	const hash = createHash("sha256");
+	for (const path of paths) {
+		hash.update(path);
+		hash.update(await worktreePathDigest(run, root, path, signal));
+	}
+	return hash.digest("hex");
+}
+async function worktreePathDigest(run, root, path, signal) {
+	const absolute = resolve(root, path);
+	let stat;
+	try {
+		stat = await lstat(absolute);
+	} catch (error) {
+		if (error.code === "ENOENT") return "missing";
+		throw error;
+	}
+	const hash = createHash("sha256").update(String(stat.mode));
+	if (stat.isSymbolicLink()) hash.update(await readlink(absolute));
+	else if (stat.isFile()) {
+		const handle = await open(absolute, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+		try {
+			if (!(await handle.stat()).isFile() || !(await lstat(absolute)).isFile()) throw new GitError(`dsh-git-commit: file changed while reading (${path})`);
+			for await (const chunk of handle.createReadStream({ autoClose: false })) {
+				signal?.throwIfAborted();
+				hash.update(chunk);
+			}
+			if (!(await lstat(absolute)).isFile()) throw new GitError(`dsh-git-commit: file changed while reading (${path})`);
+		} finally {
+			await handle.close();
+		}
+	} else if (stat.isDirectory()) {
+		hash.update(await run([
+			"-C",
+			absolute,
+			"rev-parse",
+			"HEAD"
+		], {
+			cwd: root,
+			signal
+		}));
+		hash.update(await run([
+			"-C",
+			absolute,
+			"status",
+			"--porcelain=v1",
+			"-z"
+		], {
+			cwd: root,
+			signal
+		}));
+	}
+	return hash.digest("hex");
+}
+async function recentSubjects(run, root, count, signal) {
+	return (await run([
+		"log",
+		`-${count}`,
+		"--pretty=%s"
+	], {
+		cwd: root,
+		signal
+	}).catch(() => "")).split("\n").map((line) => line.trim()).filter(Boolean);
+}
+/** Combined staged+worktree stat and diff against HEAD for the given paths. */
+async function diffAgainstHead(run, root, paths, signal) {
+	const args = paths.length > 0 ? ["--", ...paths] : [];
+	return {
+		stat: await run([
+			"diff",
+			"HEAD",
+			"--stat",
+			"--no-color",
+			...args
+		], {
+			cwd: root,
+			signal
+		}).catch(() => ""),
+		diff: await run([
+			"diff",
+			"HEAD",
+			"--no-color",
+			"--no-ext-diff",
+			...args
+		], {
+			cwd: root,
+			signal
+		}).catch(() => "")
+	};
+}
+async function untrackedPreview(root, path) {
+	try {
+		const absolute = resolve(root, path);
+		const rootReal = await realpath(root);
+		const withinRoot = async () => {
+			const target = await realpath(absolute);
+			const rel = relative(rootReal, target);
+			return rel !== "" && rel !== ".." && !rel.startsWith(`..${String.fromCharCode(47)}`) && !rel.startsWith(`..${String.fromCharCode(92)}`) && !isAbsolute(rel);
+		};
+		if (!await withinRoot()) return {
+			path,
+			preview: "",
+			binary: true
+		};
+		if (!(await lstat(absolute)).isFile()) return {
+			path,
+			preview: "",
+			binary: true
+		};
+		const handle = await open(absolute, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+		let buffer;
+		try {
+			const bounded = Buffer.alloc(MAX_UNTRACKED_PREVIEW_CHARS * 4);
+			const { bytesRead } = await handle.read(bounded, 0, bounded.length, 0);
+			buffer = bounded.subarray(0, bytesRead);
+		} finally {
+			await handle.close();
+		}
+		if (!await withinRoot() || !(await lstat(absolute)).isFile()) return {
+			path,
+			preview: "",
+			binary: true
+		};
+		if (buffer.includes(0)) return {
+			path,
+			preview: "",
+			binary: true
+		};
+		return {
+			path,
+			preview: buffer.toString("utf8").slice(0, MAX_UNTRACKED_PREVIEW_CHARS),
+			binary: false
+		};
+	} catch {
+		return {
+			path,
+			preview: "",
+			binary: true
+		};
+	}
+}
+async function indexBytes(path) {
+	try {
+		return await readFile(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+}
+async function headOid(run, root) {
+	try {
+		return (await run([
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		], { cwd: root })).trim();
+	} catch (error) {
+		if (error instanceof GitError && /Needed a single revision|not a valid object name HEAD/u.test(error.stderr)) return "";
+		throw error;
+	}
+}
+/**
+* Commit each group from the worktree. `--only` keeps other staged paths out of
+* this commit; an exact index backup protects the current group on failure.
+*/
+async function commitGroups(run, root, groups, selected, signal, verify) {
+	const commits = [];
+	for (const group of groups) {
+		if (group.files.length === 0) continue;
+		const paths = group.files.flatMap((path) => {
+			const file = selected.find((file) => file.path === path);
+			return file?.status === "renamed" && file.origin ? [path, file.origin] : [path];
+		});
+		await verify?.(paths);
+		const gitPath = (await run([
+			"rev-parse",
+			"--git-path",
+			"index"
+		], {
+			cwd: root,
+			signal
+		})).trim();
+		const indexPath = isAbsolute(gitPath) ? gitPath : resolve(root, gitPath);
+		const backupDir = await mkdtemp(join(tmpdir(), "dsh-git-commit-"));
+		const backupPath = join(backupDir, "index");
+		let hadIndex = true;
+		try {
+			try {
+				await copyFile(indexPath, backupPath);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				hadIndex = false;
+			}
+			const head = await headOid(run, root);
+			const originalIndex = await indexBytes(indexPath);
+			if (hadIndex ? !originalIndex?.equals(await readFile(backupPath)) : originalIndex !== void 0) throw new GitError("dsh-git-commit: index changed before committing; retry");
+			let stagedIndex = originalIndex;
+			try {
+				await run([
+					"add",
+					"-A",
+					"--",
+					...group.files
+				], {
+					cwd: root,
+					signal
+				});
+				stagedIndex = await indexBytes(indexPath);
+				await run([
+					"commit",
+					"--quiet",
+					"--only",
+					"-m",
+					group.message,
+					"--",
+					...paths
+				], {
+					cwd: root,
+					signal
+				});
+				const hash = (await run([
+					"rev-parse",
+					"--short",
+					"HEAD"
+				], {
+					cwd: root,
+					signal
+				})).trim();
+				commits.push({
+					hash,
+					skipped: false
+				});
+			} catch (error) {
+				const currentHead = await headOid(run, root);
+				const currentIndex = await indexBytes(indexPath);
+				const indexUntouched = currentIndex === void 0 ? stagedIndex === void 0 : currentIndex.equals(stagedIndex ?? Buffer.alloc(0));
+				if (currentHead === head && indexUntouched) {
+					if (hadIndex) await copyFile(backupPath, indexPath);
+					else await rm(indexPath, { force: true });
+				}
+				throw error;
+			}
+		} finally {
+			await rm(backupDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	return commits;
+}
+/** One deterministic commit for every selected path; used when the model plan is unavailable. */
+function fallbackGroup(files, localeHint) {
+	return {
+		message: localeHint === "zh" ? `chore: 提交 ${files.length} 个文件的修改` : `chore: commit changes to ${files.length} file${files.length === 1 ? "" : "s"}`,
+		files: files.map((file) => file.path)
+	};
+}
+//#endregion
+//#region src/plan.ts
+function planSystemPrompt() {
+	return [
+		"You split a git working-tree change set into a small number of coherent commits.",
+		"Return exactly one JSON object: {\"groups\":[{\"message\":\"<commit message>\",\"files\":[\"<path>\",...]}]}.",
+		"Rules:",
+		"- Every listed file must appear in exactly one group; do not invent paths.",
+		"- One to five groups. Group files that belong to the same logical change.",
+		"- Order groups so earlier commits do not depend on later ones.",
+		"- Each message is a single line of at most 72 characters, no trailing period.",
+		"- Match the language and style of the recent commit subjects when provided; otherwise use English conventional-commit style.",
+		"- Return no Markdown, code fence, or explanation."
+	].join("\n");
+}
+function truncateMiddle(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	const half = Math.floor((maxChars - 40) / 2);
+	return `${text.slice(0, half)}\n… [${text.length - maxChars} chars omitted] …\n${text.slice(-half)}`;
+}
+function buildPlanInput(input) {
+	const sections = [];
+	sections.push("Scope: all current workspace changes of the repository.");
+	if (input.recentSubjects.length > 0) sections.push(["Recent commit subjects (style reference):", ...input.recentSubjects.map((s) => `- ${s}`)].join("\n"));
+	const manifest = input.files.map((file) => `- ${statusLetter(file.status)} ${file.origin ? `${file.origin} ${file.status === "copied" ? "=>" : "->"} ` : ""}${file.path}`).join("\n");
+	sections.push(`Changed files:\n${manifest}`);
+	if (input.stat.trim()) sections.push(`Diff stat:\n${input.stat.trim()}`);
+	if (input.diff.trim()) sections.push(`Diff against HEAD:\n${input.diff}`);
+	for (const untracked of input.untracked) sections.push(untracked.binary ? `New binary file: ${untracked.path}` : `New file ${untracked.path}:\n${untracked.preview}`);
+	return truncateMiddle(sections.join("\n\n"), MAX_MANIFEST_CHARS);
+}
+function sanitizeMessage(raw) {
+	if (typeof raw !== "string") return void 0;
+	const line = raw.replace(/\s+/gu, " ").trim().replace(/\.+$/u, "");
+	if (!line) return void 0;
+	return line.length > 120 ? line.slice(0, 120).trim() : line;
+}
+/** Extract the first balanced top-level JSON object from model output. */
+function extractJsonObject(text) {
+	const candidate = /```(?:json)?\s*([\s\S]*?)```/u.exec(text)?.[1] ?? text;
+	const start = candidate.indexOf("{");
+	if (start === -1) return void 0;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let index = start; index < candidate.length; index += 1) {
+		const char = candidate[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") inString = true;
+		else if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return candidate.slice(start, index + 1);
+		}
+	}
+}
+/**
+* Validate the model plan against the exact change set. Returns undefined when
+* the output is malformed, covers the wrong files, or duplicates a file.
+*/
+function parsePlan(text, files) {
+	const json = extractJsonObject(text);
+	if (!json) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+	const groups = parsed.groups;
+	if (!Array.isArray(groups) || groups.length === 0 || groups.length > 8) return void 0;
+	const allowed = new Set(files.map((file) => file.path));
+	const seen = /* @__PURE__ */ new Set();
+	const plan = [];
+	for (const group of groups) {
+		if (!group || typeof group !== "object") return void 0;
+		const message = sanitizeMessage(group.message);
+		const paths = group.files;
+		if (!message || !Array.isArray(paths) || paths.length === 0) return void 0;
+		const groupFiles = [];
+		for (const path of paths) {
+			if (typeof path !== "string" || !allowed.has(path) || seen.has(path)) return void 0;
+			seen.add(path);
+			groupFiles.push(path);
+		}
+		plan.push({
+			message,
+			files: groupFiles
+		});
+	}
+	if (seen.size !== allowed.size) return void 0;
+	return plan;
+}
+//#endregion
+//#region src/service.ts
+var CommitRunError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "CommitRunError";
+		this.code = code;
+	}
+};
+function modelInfo(route) {
+	if (!route?.provider || !route.model) return void 0;
+	return {
+		provider: route.provider,
+		model: route.model,
+		source: route.source
+	};
+}
+function looksChinese(subjects) {
+	return subjects.some((subject) => /[一-鿿]/u.test(subject));
+}
+function normalizeCwd(cwd) {
+	if (typeof cwd !== "string") return void 0;
+	const normalized = cwd.trim().replaceAll("\\", "/");
+	if (!normalized) return void 0;
+	return normalized === "/" || /^[A-Za-z]:\/$/.test(normalized) ? normalized : normalized.replace(/\/+$/, "");
+}
+var GitCommitService = class {
+	deps;
+	run;
+	preview;
+	scope;
+	disposePurpose;
+	running;
+	constructor(deps) {
+		this.deps = deps;
+		this.run = deps.run ?? execGit;
+		this.preview = deps.preview ?? untrackedPreview;
+	}
+	start() {
+		this.scope = this.deps.ai.activate(this.deps.plugin);
+		this.disposePurpose = this.scope.registerPurpose({
+			id: PURPOSE_ID,
+			label: "Git 提交",
+			defaultTarget: {
+				kind: "role",
+				role: "weak"
+			},
+			maxOutputTokens: DEFAULT_MAX_OUTPUT_TOKENS
+		});
+	}
+	async dispose() {
+		this.disposePurpose?.();
+		this.scope?.dispose();
+		this.scope = void 0;
+		await this.running?.catch(() => {});
+	}
+	async resolveRepo(sessionId) {
+		const session = this.deps.sessions.get(sessionId);
+		if (!session) throw new CommitRunError("no-session", "dsh-git-commit: session is not live on this host");
+		const cwd = normalizeCwd(session.header?.cwd);
+		if (!cwd) throw new CommitRunError("no-cwd", "dsh-git-commit: session has no working directory");
+		try {
+			return await repoInfo(this.run, cwd);
+		} catch (error) {
+			if (isGitMissing(error)) throw new CommitRunError("no-git", "dsh-git-commit: git executable not found");
+			throw new CommitRunError("not-a-repo", "dsh-git-commit: session directory is not inside a git repository");
+		}
+	}
+	async status(sessionId) {
+		let resolved;
+		try {
+			resolved = await this.resolveRepo(sessionId);
+		} catch (error) {
+			if (error instanceof CommitRunError) return {
+				available: false,
+				reason: error.code,
+				detail: error.message,
+				workspace: { files: 0 }
+			};
+			throw error;
+		}
+		const changes = await workingTreeChanges(this.run, resolved.root);
+		let model;
+		if (this.scope?.active) model = await this.deps.ai.resolve(PURPOSE_ID, sessionId).then(modelInfo, () => void 0);
+		return {
+			available: true,
+			root: resolved.root,
+			branch: resolved.branch,
+			workspace: { files: changes.length },
+			...model ? { model } : {}
+		};
+	}
+	async commit(sessionId, signal) {
+		if (this.running) throw new CommitRunError("busy", "dsh-git-commit: a commit run is already in progress");
+		const run = this.runCommit(sessionId, signal);
+		this.running = run;
+		try {
+			return await run;
+		} finally {
+			this.running = void 0;
+		}
+	}
+	async runCommit(sessionId, signal) {
+		const session = this.deps.sessions.get(sessionId);
+		const sessionCwd = normalizeCwd(session?.header?.cwd);
+		const resolved = await this.resolveRepo(sessionId);
+		const assertReady = () => {
+			signal?.throwIfAborted();
+			if (!this.scope?.active) throw new CommitRunError("cancelled", "dsh-git-commit: plugin is no longer active");
+			const currentSession = this.deps.sessions.get(sessionId);
+			if (currentSession !== session || normalizeCwd(currentSession?.header?.cwd) !== sessionCwd) throw new CommitRunError("session-changed", "dsh-git-commit: session workspace changed during planning");
+			if (this.deps.agents?.get(sessionId)?.status === "running") throw new CommitRunError("session-running", "dsh-git-commit: wait for the session turn to finish");
+		};
+		assertReady();
+		const initial = await workspaceSnapshot(this.run, resolved.root, signal);
+		const branchRef = await this.run([
+			"symbolic-ref",
+			"--quiet",
+			"HEAD"
+		], {
+			cwd: resolved.root,
+			signal
+		}).catch(() => "DETACHED");
+		const selected = initial.files;
+		if (selected.length === 0) throw new CommitRunError("no-changes", "dsh-git-commit: working tree is clean");
+		const paths = selected.flatMap((file) => file.status === "renamed" && file.origin ? [file.path, file.origin] : [file.path]);
+		const originalVersions = await pathVersions(this.run, resolved.root, paths, signal);
+		const [{ stat, diff }, subjects] = await Promise.all([diffAgainstHead(this.run, resolved.root, paths, signal), recentSubjects(this.run, resolved.root, 10, signal)]);
+		const untracked = [];
+		for (const file of selected) if (file.status === "untracked") untracked.push(await this.preview(resolved.root, file.path));
+		let groups;
+		let model;
+		const scope = this.scope;
+		if (scope?.active) try {
+			const result = await scope.run({
+				purpose: PURPOSE_ID,
+				sessionId,
+				input: buildPlanInput({
+					files: selected,
+					recentSubjects: subjects,
+					stat,
+					diff,
+					untracked
+				}),
+				system: planSystemPrompt(),
+				sourceVersion: `${sessionId}:${initial.fingerprint}`,
+				contractVersion: 1,
+				promptVersion: PROMPT_VERSION,
+				schemaVersion: SCHEMA_VERSION,
+				signal,
+				priority: "interactive"
+			});
+			model = modelInfo(result.receipt.route);
+			if (result.receipt.status === "cancelled") throw new CommitRunError("cancelled", "dsh-git-commit: planning was cancelled");
+			groups = parsePlan(result.text, selected);
+		} catch (error) {
+			if (error instanceof CommitRunError) throw error;
+			groups = void 0;
+		}
+		assertReady();
+		if ((await workspaceSnapshot(this.run, resolved.root, signal)).fingerprint !== initial.fingerprint) throw new CommitRunError("workspace-changed", "dsh-git-commit: workspace changed during planning; retry the commit");
+		const effective = groups ?? [fallbackGroup(selected, looksChinese(subjects) ? "zh" : "en")];
+		const executed = await commitGroups(this.run, resolved.root, effective, selected, signal, async () => {
+			assertReady();
+			if (await this.run([
+				"symbolic-ref",
+				"--quiet",
+				"HEAD"
+			], {
+				cwd: resolved.root,
+				signal
+			}).catch(() => "DETACHED") !== branchRef) throw new CommitRunError("workspace-changed", "dsh-git-commit: branch changed during the commit run");
+			if (await pathVersions(this.run, resolved.root, paths, signal) !== originalVersions) throw new CommitRunError("workspace-changed", "dsh-git-commit: selected file changed during the commit run");
+			await workingTreeChanges(this.run, resolved.root, signal);
+		});
+		const commits = [];
+		for (let index = 0; index < effective.length; index += 1) {
+			const result = executed[index];
+			const group = effective[index];
+			if (!result || !group || result.skipped) continue;
+			commits.push({
+				hash: result.hash,
+				message: group.message,
+				files: group.files
+			});
+		}
+		if (commits.length === 0) throw new CommitRunError("no-changes", "dsh-git-commit: nothing was committed");
+		return {
+			branch: resolved.branch,
+			commits,
+			fallback: groups === void 0,
+			...model ? { model } : {}
+		};
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = PLUGIN_NAME;
+const inject = [
+	"aiServices",
+	"sessions",
+	"agents",
+	"connection",
+	"webServer"
+];
+function stringField(payload, key) {
+	if (!payload || typeof payload !== "object") return void 0;
+	const value = payload[key];
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function fail(error) {
+	if (error instanceof CommitRunError) return {
+		ok: false,
+		error: {
+			code: error.code,
+			message: error.message
+		}
+	};
+	return {
+		ok: false,
+		error: {
+			code: "internal",
+			message: error instanceof Error ? error.message : String(error)
+		}
+	};
+}
+async function handleRpc(service, endpoint, payload, signal) {
+	try {
+		switch (endpoint) {
+			case "status": {
+				const sessionId = stringField(payload, "sessionId");
+				if (!sessionId) return {
+					ok: false,
+					error: {
+						code: "bad-request",
+						message: "sessionId is required"
+					}
+				};
+				return {
+					ok: true,
+					value: await service.status(sessionId)
+				};
+			}
+			case "commit": {
+				const sessionId = stringField(payload, "sessionId");
+				if (!sessionId) return {
+					ok: false,
+					error: {
+						code: "bad-request",
+						message: "sessionId is required"
+					}
+				};
+				return {
+					ok: true,
+					value: await service.commit(sessionId, signal)
+				};
+			}
+			default: return {
+				ok: false,
+				error: {
+					code: "not-found",
+					message: `unknown endpoint: ${endpoint}`
+				}
+			};
+		}
+	} catch (error) {
+		return fail(error);
+	}
+}
+function apply(ctx) {
+	const host = ctx;
+	const service = new GitCommitService({
+		plugin: PLUGIN_NAME,
+		ai: host.aiServices,
+		sessions: host.sessions,
+		agents: host.agents
+	});
+	service.start();
+	ctx.provide("gitCommit", service);
+	ctx.effect(() => async () => {
+		await service.dispose();
+	}, "git-commit.lifecycle");
+	ctx.effect(() => registerHostRpc(host, RPC_CHANNEL, (endpoint, payload, signal) => handleRpc(service, endpoint, payload, signal)), "git-commit.rpc");
+}
+//#endregion
+export { GitCommitService, apply, buildPlanInput, handleRpc, inject, name, parsePlan, parsePorcelain };
+
+//# sourceMappingURL=index.js.map