@klarkxy/dsh-git-commit 0.1.6 → 0.2.1

package/lib/index.js

@@ -1,7 +1,8 @@
 import { DEFAULT_MAX_OUTPUT_TOKENS, MAX_MANIFEST_CHARS, MAX_UNTRACKED_PREVIEW_CHARS, PLUGIN_NAME, RPC_CHANNEL, SETTINGS_KEY, defaultSettings, normalizeFallback, normalizeModelRoute } from "./contracts.js";
 import { registerHostRpc } from "@klarkxy/dsh-plugin-kit/host-rpc";
+import { notifyModelSettingsChanged, registerModelSettings } from "@klarkxy/dsh-plugin-kit/model-settings";
+import { modelRouteOverride } from "@klarkxy/dsh-model-route";
 import { callLlmText, resolveFeatureModel } from "@klarkxy/dsh-plugin-kit";
-import { modelMenuOverride } from "@klarkxy/dsh-plugin-kit/model-menu";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
@@ -343,6 +344,19 @@ async function untrackedPreview(root, path) {
 		};
 	}
 }
+/** Known commits or an uncertain current group must survive a rejected run. */
+var PartialCommitError = class extends Error {
+	commits;
+	cause;
+	uncertain;
+	constructor(commits, cause, uncertain) {
+		super(cause instanceof Error ? cause.message : String(cause));
+		this.name = "PartialCommitError";
+		this.commits = commits;
+		this.cause = cause;
+		this.uncertain = uncertain;
+	}
+};
 async function indexBytes(path) {
 	try {
 		return await readFile(path);
@@ -369,26 +383,38 @@ async function headOid(run, root) {
 */
 async function commitGroups(run, root, groups, selected, signal, verify) {
 	const commits = [];
+	let partialFailure;
+	const fail = (error) => {
+		if (error instanceof PartialCommitError) {
+			partialFailure = error;
+			throw error;
+		}
+		if (commits.length === 0) throw error;
+		partialFailure = new PartialCommitError(commits, error);
+		throw partialFailure;
+	};
 	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;
+		let backupDir;
 		try {
+			signal?.throwIfAborted();
+			await verify?.(paths);
+			const gitPath = (await run([
+				"rev-parse",
+				"--git-path",
+				"index"
+			], {
+				cwd: root,
+				signal
+			})).trim();
+			const indexPath = isAbsolute(gitPath) ? gitPath : resolve(root, gitPath);
+			backupDir = await mkdtemp(join(tmpdir(), "dsh-git-commit-"));
+			const backupPath = join(backupDir, "index");
+			let hadIndex = true;
 			try {
 				await copyFile(indexPath, backupPath);
 			} catch (error) {
@@ -399,7 +425,10 @@ async function commitGroups(run, root, groups, selected, signal, verify) {
 			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;
+			let committed = false;
+			let commitInvoked = false;
 			try {
+				signal?.throwIfAborted();
 				await run([
 					"add",
 					"-A",
@@ -410,6 +439,8 @@ async function commitGroups(run, root, groups, selected, signal, verify) {
 					signal
 				});
 				stagedIndex = await indexBytes(indexPath);
+				signal?.throwIfAborted();
+				commitInvoked = true;
 				await run([
 					"commit",
 					"--quiet",
@@ -422,33 +453,71 @@ async function commitGroups(run, root, groups, selected, signal, verify) {
 					cwd: root,
 					signal
 				});
-				const hash = (await run([
-					"rev-parse",
-					"--short",
-					"HEAD"
-				], {
-					cwd: root,
-					signal
-				})).trim();
+				committed = true;
+				let hash = "";
+				try {
+					hash = (await run([
+						"rev-parse",
+						"--short",
+						"HEAD"
+					], { cwd: root })).trim();
+				} catch (error) {
+					commits.push({
+						hash: "",
+						skipped: false
+					});
+					throw error;
+				}
+				if (!hash) {
+					commits.push({
+						hash: "",
+						skipped: false
+					});
+					throw new GitError("dsh-git-commit: commit was created but its hash could not be read");
+				}
 				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 });
+				if (!committed) {
+					let currentHead;
+					try {
+						currentHead = await headOid(run, root);
+					} catch {
+						if (commitInvoked) throw new PartialCommitError(commits, error, {
+							message: group.message,
+							files: [...group.files]
+						});
+						throw error;
+					}
+					if (currentHead !== head) {
+						if (commitInvoked) throw new PartialCommitError(commits, error, {
+							message: group.message,
+							files: [...group.files]
+						});
+						throw error;
+					}
+					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;
 			}
+		} catch (error) {
+			fail(error);
 		} finally {
-			await rm(backupDir, {
-				recursive: true,
-				force: true
-			});
+			if (backupDir) try {
+				await rm(backupDir, {
+					recursive: true,
+					force: true
+				});
+			} catch (error) {
+				fail(partialFailure ?? error);
+			}
 		}
 	}
 	return commits;
@@ -563,10 +632,13 @@ function parsePlan(text, files) {
 //#region src/service.ts
 var CommitRunError = class extends Error {
 	code;
-	constructor(code, message) {
+	/** Commits already created when this run stopped. Absent when nothing was written. */
+	partial;
+	constructor(code, message, partial) {
 		super(message);
-		this.name = "CommitRunError";
+		this.name = code === "cancelled" ? "AbortError" : "CommitRunError";
 		this.code = code;
+		this.partial = partial;
 	}
 };
 function modelInfo(route, source) {
@@ -594,36 +666,83 @@ var GitCommitService = class {
 	settings;
 	settingsPending = Promise.resolve();
 	settingsReady;
+	settingsFailure;
+	settingsAdopted = false;
 	disposed = false;
+	/** Aborted on unload so an in-flight model plan receives the same signal as a cancelled request. */
+	lifetime = new AbortController();
 	constructor(deps) {
 		this.deps = deps;
 		this.run = deps.run ?? execGit;
 		this.preview = deps.preview ?? untrackedPreview;
 		this.settings = defaultSettings();
 		this.settingsReady = deps.settings?.load().then((loaded) => {
-			if (loaded) this.settings = structuredClone(loaded);
+			if (loaded && !this.settingsAdopted) this.settings = structuredClone(loaded);
 		}, () => {
-			this.settings = defaultSettings();
+			if (!this.settingsAdopted) this.settingsFailure = new CommitRunError("settings-unavailable", "dsh-git-commit: saved settings could not be read; reload the plugin before retrying");
 		}) ?? Promise.resolve();
 	}
-	/** Apply a freshly loaded settings row; the default stays until a row is read. */
+	/** A refreshed row wins over a pending initial read. */
 	adoptSettings(next) {
+		if (this.disposed) throw new CommitRunError("disposed", "dsh-git-commit: plugin disabled");
+		this.settingsAdopted = true;
+		this.settingsFailure = void 0;
 		this.settings = structuredClone(next);
 	}
+	/** Existing synchronous snapshot API; host operations wait for initialization first. */
 	getSettings() {
+		this.workSignal();
+		if (this.settingsFailure) throw this.settingsFailure;
 		return structuredClone(this.settings);
 	}
-	selectedModel() {
-		const page = modelMenuOverride(this.settings.model);
+	async ready() {
+		this.workSignal();
+		await this.settingsReady;
+		this.workSignal();
+		if (this.settingsFailure) throw this.settingsFailure;
+	}
+	/** Request cancellation and plugin unload share one signal. A disposed service rejects before any new work. */
+	workSignal(signal) {
+		if (this.disposed || this.lifetime.signal.aborted) throw new CommitRunError("disposed", "dsh-git-commit: plugin is no longer active");
+		return signal ? AbortSignal.any([signal, this.lifetime.signal]) : this.lifetime.signal;
+	}
+	async waitForSettings(signal) {
+		signal?.throwIfAborted();
+		if (!signal) {
+			await this.ready();
+			return;
+		}
+		let onAbort = () => {};
+		const aborted = new Promise((_, reject) => {
+			onAbort = () => {
+				try {
+					signal.throwIfAborted();
+				} catch (error) {
+					reject(error);
+				}
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			if (signal.aborted) onAbort();
+		});
+		try {
+			await Promise.race([this.settingsReady, aborted]);
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
+		signal.throwIfAborted();
+		if (this.settingsFailure) throw this.settingsFailure;
+	}
+	selectedModel(sessionId) {
+		const page = modelRouteOverride(this.settings.model);
 		return {
-			route: resolveFeatureModel(this.deps.host, page),
+			route: resolveFeatureModel(this.deps.host, page, sessionId),
 			source: page ? "page" : "default"
 		};
 	}
 	async updateSettings(patch, expectedRevision) {
 		const detached = structuredClone(patch);
 		const result = this.settingsPending.then(async () => {
-			await this.settingsReady;
+			await this.ready();
 			if (this.disposed) throw new CommitRunError("disposed", "dsh-git-commit: plugin disabled");
 			if (expectedRevision !== this.settings.revision) throw new CommitRunError("stale", "dsh-git-commit: settings changed; reload and retry");
 			const next = {
@@ -633,7 +752,10 @@ var GitCommitService = class {
 			};
 			await this.deps.settings?.save(next);
 			this.settings = next;
-			return this.getSettings();
+			try {
+				this.deps.onSettingsChanged?.(next.revision);
+			} catch {}
+			return structuredClone(next);
 		});
 		this.settingsPending = result.then(() => {}, () => {});
 		return result;
@@ -641,25 +763,30 @@ var GitCommitService = class {
 	start() {}
 	async dispose() {
 		this.disposed = true;
+		this.lifetime.abort();
+		await this.settingsReady;
 		await this.settingsPending;
 		await this.running?.catch(() => {});
 	}
-	async resolveRepo(sessionId) {
+	async resolveRepo(sessionId, signal) {
 		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);
+			return await repoInfo(this.run, cwd, signal);
 		} catch (error) {
+			signal?.throwIfAborted();
 			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) {
+	async status(sessionId, signal) {
+		const work = this.workSignal(signal);
+		await this.waitForSettings(work);
 		let resolved;
 		try {
-			resolved = await this.resolveRepo(sessionId);
+			resolved = await this.resolveRepo(sessionId, work);
 		} catch (error) {
 			if (error instanceof CommitRunError) return {
 				available: false,
@@ -669,8 +796,9 @@ var GitCommitService = class {
 			};
 			throw error;
 		}
-		const changes = await workingTreeChanges(this.run, resolved.root);
-		const selected = this.selectedModel();
+		const changes = await workingTreeChanges(this.run, resolved.root, work);
+		work.throwIfAborted();
+		const selected = this.selectedModel(sessionId);
 		const model = modelInfo(selected.route, selected.source);
 		return {
 			available: true,
@@ -681,19 +809,27 @@ var GitCommitService = class {
 		};
 	}
 	async commit(sessionId, signal) {
+		if (this.disposed || this.lifetime.signal.aborted) throw new CommitRunError("disposed", "dsh-git-commit: plugin is no longer active");
 		if (this.running) throw new CommitRunError("busy", "dsh-git-commit: a commit run is already in progress");
-		const run = this.runCommit(sessionId, signal);
+		const work = this.workSignal(signal);
+		const run = this.runCommit(sessionId, work);
 		this.running = run;
 		try {
 			return await run;
+		} catch (error) {
+			if (error instanceof CommitRunError && error.partial) throw error;
+			if (work.aborted) throw new CommitRunError("cancelled", "dsh-git-commit: commit run cancelled");
+			throw error;
 		} finally {
 			this.running = void 0;
 		}
 	}
 	async runCommit(sessionId, signal) {
+		await this.waitForSettings(signal);
+		if (this.disposed || signal?.aborted) throw new CommitRunError("cancelled", "dsh-git-commit: plugin is no longer active");
 		const session = this.deps.sessions.get(sessionId);
 		const sessionCwd = normalizeCwd(session?.header?.cwd);
-		const resolved = await this.resolveRepo(sessionId);
+		const resolved = await this.resolveRepo(sessionId, signal);
 		const assertReady = () => {
 			signal?.throwIfAborted();
 			if (this.disposed || !this.deps.llm) throw new CommitRunError("cancelled", "dsh-git-commit: plugin is no longer active");
@@ -717,11 +853,14 @@ var GitCommitService = class {
 		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));
+		for (const file of selected) {
+			assertReady();
+			if (file.status === "untracked") untracked.push(await this.preview(resolved.root, file.path));
+		}
 		let groups;
 		let planFailure = "no model route was available";
 		let model;
-		const planned = this.selectedModel();
+		const planned = this.selectedModel(sessionId);
 		if (planned.route) try {
 			const result = await callLlmText(this.deps.llm, {
 				plugin: this.deps.plugin,
@@ -735,13 +874,14 @@ var GitCommitService = class {
 					untracked
 				}),
 				maxTokens: DEFAULT_MAX_OUTPUT_TOKENS,
-				signal: signal ?? new AbortController().signal,
+				signal,
 				sessionId
 			});
 			model = modelInfo(result, planned.source);
 			groups = parsePlan(result.text, selected);
 			if (!groups) planFailure = "the model returned a plan that does not cover the change set";
 		} catch (error) {
+			assertReady();
 			if (error instanceof CommitRunError) throw error;
 			planFailure = error instanceof Error ? error.message : String(error);
 		}
@@ -749,30 +889,59 @@ var GitCommitService = class {
 		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
+		const describe = (executed) => {
+			const commits = [];
+			for (let index = 0; index < executed.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]
+				});
+			}
+			return commits;
+		};
+		let executed;
+		try {
+			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);
+			});
+		} catch (error) {
+			if (!(error instanceof PartialCommitError)) throw error;
+			const commits = describe(error.commits);
+			const cause = error.cause;
+			const cancelled = signal?.aborted || typeof cause === "object" && cause !== null && cause.code === "cancelled" || cause instanceof Error && cause.name === "AbortError";
+			const code = cause instanceof CommitRunError ? cause.code : cancelled ? "cancelled" : "commit-failed";
+			const message = cause instanceof Error ? cause.message : String(cause);
+			throw new CommitRunError(code, message, {
+				branch: resolved.branch,
+				commits,
+				fallback: groups === void 0,
+				failure: {
+					code,
+					message
+				},
+				remaining: effective.slice(error.commits.length + (error.uncertain ? 1 : 0)).map((group) => ({
+					message: group.message,
+					files: [...group.files]
+				})),
+				...error.uncertain ? { uncertain: [error.uncertain] } : {},
+				...model ? { model } : {}
 			});
 		}
+		const commits = describe(executed);
 		if (commits.length === 0) throw new CommitRunError("no-changes", "dsh-git-commit: nothing was committed");
 		return {
 			branch: resolved.branch,
@@ -825,7 +994,9 @@ const inject = [
 	"agents",
 	"storageDomain",
 	"connection",
-	"webServer"
+	"webServer",
+	"sessionProjections",
+	"agentDefaultModel"
 ];
 function stringField(payload, key) {
 	if (!payload || typeof payload !== "object") return void 0;
@@ -837,7 +1008,8 @@ function fail(error) {
 		ok: false,
 		error: {
 			code: error.code,
-			message: error.message
+			message: error.message,
+			...error.partial ? { partial: error.partial } : {}
 		}
 	};
 	return {
@@ -862,13 +1034,15 @@ async function handleRpc(service, endpoint, payload, signal) {
 				};
 				return {
 					ok: true,
-					value: await service.status(sessionId)
+					value: await service.status(sessionId, signal)
 				};
 			}
-			case "settings": return {
-				ok: true,
-				value: service.getSettings()
-			};
+			case "settings":
+				await service.ready();
+				return {
+					ok: true,
+					value: service.getSettings()
+				};
 			case "settings.update": {
 				const parsed = updateSettingsSchema.safeParse(payload);
 				if (!parsed.success) return {
@@ -918,6 +1092,7 @@ function apply(ctx) {
 	const tablePromise = domainPromise.then((domain) => domain.table("settings"));
 	const service = new GitCommitService({
 		plugin: PLUGIN_NAME,
+		onSettingsChanged: (revision) => notifyModelSettingsChanged(ctx, PLUGIN_NAME, revision),
 		llm: host.llm,
 		host,
 		sessions: host.sessions,
@@ -936,6 +1111,43 @@ function apply(ctx) {
 		await (await domainPromise).close();
 	}, "git-commit.lifecycle");
 	ctx.effect(() => registerHostRpc(host, RPC_CHANNEL, (endpoint, payload, signal) => handleRpc(service, endpoint, payload, signal)), "git-commit.rpc");
+	ctx.effect(() => registerModelSettings(ctx, {
+		ns: PLUGIN_NAME,
+		title: {
+			zh: "Git 提交",
+			en: "Git Commit"
+		},
+		async read(signal) {
+			await service.ready();
+			signal.throwIfAborted();
+			const settings = service.getSettings();
+			return {
+				revision: settings.revision,
+				fields: [{
+					path: ["model"],
+					label: {
+						zh: "提交模型",
+						en: "Commit model"
+					},
+					current: settings.model,
+					followLabel: {
+						zh: "当前会话 / 宿主默认模型",
+						en: "Current conversation / host default"
+					},
+					allowFollow: true
+				}]
+			};
+		},
+		async write(path, route, expectedRevision, signal) {
+			if (path.length !== 1 || path[0] !== "model") throw new Error("Unknown Git Commit model setting");
+			await service.ready();
+			signal.throwIfAborted();
+			return service.updateSettings({
+				...service.getSettings(),
+				model: route
+			}, expectedRevision);
+		}
+	}), "git-commit.model-settings");
 }
 //#endregion
 export { GitCommitService, apply, buildPlanInput, defaultSettings, handleRpc, inject, name, normalizeFallback, normalizeModelRoute, parsePlan, parsePorcelain };