@openspecui/server 2.2.0 → 2.3.3

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { createServer as createServer$1 } from "node:net";
 import { serve } from "@hono/node-server";
-import { CliExecutor, CodeEditorThemeSchema, ConfigManager, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, OpenSpecAdapter, OpenSpecWatcher, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalRendererEngineSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, sniffGlobalCli } from "@openspecui/core";
+import { CliExecutor, CodeEditorThemeSchema, ConfigManager, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, GitConfigSchema, OpenSpecAdapter, OpenSpecWatcher, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalRendererEngineSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, sniffGlobalCli } from "@openspecui/core";
 import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
 import { Hono } from "hono";
@@ -1359,27 +1359,54 @@ function createCliStreamObservable(startStream) {
 const gitPanelCaches = {
 	overview: /* @__PURE__ */ new Map(),
 	entries: /* @__PURE__ */ new Map(),
+	meta: /* @__PURE__ */ new Map(),
 	shell: /* @__PURE__ */ new Map(),
+	files: /* @__PURE__ */ new Map(),
+	snapshot: /* @__PURE__ */ new Map(),
+	patch: /* @__PURE__ */ new Map()
+};
+const gitPanelPendingCaches = {
+	overview: /* @__PURE__ */ new Map(),
+	entries: /* @__PURE__ */ new Map(),
+	meta: /* @__PURE__ */ new Map(),
+	shell: /* @__PURE__ */ new Map(),
+	files: /* @__PURE__ */ new Map(),
+	snapshot: /* @__PURE__ */ new Map(),
 	patch: /* @__PURE__ */ new Map()
 };
 function buildCacheKey(projectDir, key) {
 	return `${resolve(projectDir)}::${key}`;
 }
-function getCacheVersion() {
-	return getDashboardGitTaskStatus().lastFinishedAt ?? 0;
+function isImmutableCommitDetailCache(scope, key) {
+	return (scope === "meta" || scope === "shell" || scope === "files" || scope === "snapshot" || scope === "patch") && key.startsWith("commit:");
+}
+function getCacheVersion(scope, key) {
+	if (isImmutableCommitDetailCache(scope, key)) return "commit-detail:immutable";
+	return `refresh:${getDashboardGitTaskStatus().lastFinishedAt ?? 0}`;
 }
 async function getCachedGitPanelValue(scope, projectDir, key, load) {
 	const cache = gitPanelCaches[scope];
+	const pendingCache = gitPanelPendingCaches[scope];
 	const cacheKey = buildCacheKey(projectDir, key);
-	const version = getCacheVersion();
+	const version = getCacheVersion(scope, key);
 	const hit = cache.get(cacheKey);
 	if (hit && hit.version === version) return hit.value;
-	const value = await load();
-	cache.set(cacheKey, {
+	const pending = pendingCache.get(cacheKey);
+	if (pending && pending.version === version) return pending.promise;
+	const promise = load().then((value) => {
+		cache.set(cacheKey, {
+			version,
+			value
+		});
+		return value;
+	}).finally(() => {
+		if (pendingCache.get(cacheKey)?.promise === promise) pendingCache.delete(cacheKey);
+	});
+	pendingCache.set(cacheKey, {
 		version,
-		value
+		promise
 	});
-	return value;
+	return promise;
 }
 
 //#endregion
@@ -1553,31 +1580,6 @@ function splitPatchLines(text) {
 	if (lines.at(-1) === "") lines.pop();
 	return lines;
 }
-async function buildTrackedPatchFile(options) {
-	const { worktreePath, file, runGit, selector } = options;
-	const patchResult = await runGit(worktreePath, selector.type === "commit" ? [
-		"show",
-		"--patch",
-		"--find-renames",
-		"--format=",
-		selector.hash,
-		"--",
-		file.path
-	] : [
-		"diff",
-		"--patch",
-		"--find-renames",
-		"HEAD",
-		"--",
-		file.path
-	]);
-	const normalized = normalizePatchState(patchResult.stdout);
-	return {
-		...file,
-		patch: normalized.patch,
-		state: patchResult.ok ? normalized.state : "unavailable"
-	};
-}
 async function buildUntrackedPatchFile(worktreePath, file) {
 	try {
 		const buffer = await readFile(resolve(worktreePath, file.path));
@@ -1701,6 +1703,198 @@ async function loadGitEntryShell(options) {
 		runGit
 	});
 }
+function buildSelectorCacheKey(selector) {
+	return selector.type === "commit" ? `commit:${selector.hash}` : "uncommitted";
+}
+function buildTrackedPatchArgs(selector) {
+	return selector.type === "commit" ? [
+		"show",
+		"--patch",
+		"--find-renames",
+		"--format=",
+		selector.hash
+	] : [
+		"diff",
+		"--patch",
+		"--find-renames",
+		"HEAD"
+	];
+}
+function decodeGitPatchPathToken(token) {
+	const trimmed = token.trim();
+	if (!trimmed || trimmed === "/dev/null") return null;
+	let value = trimmed;
+	if (value.startsWith("\"") && value.endsWith("\"") && value.length >= 2) value = value.slice(1, -1).replace(/\\([\\"])/g, "$1").replace(/\\t/g, "	").replace(/\\n/g, "\n");
+	if (value === "/dev/null") return null;
+	if (value.startsWith("a/") || value.startsWith("b/")) return normalizeGitPath(value.slice(2));
+	return normalizeGitPath(value);
+}
+function parseDiffGitHeaderPaths(line) {
+	const rest = line.slice(11).trim();
+	const quotedMatch = /^"a\/((?:[^"\\]|\\.)+)" "b\/((?:[^"\\]|\\.)+)"$/.exec(rest);
+	if (quotedMatch) return {
+		oldPath: decodeGitPatchPathToken(`"a/${quotedMatch[1] ?? ""}"`),
+		newPath: decodeGitPatchPathToken(`"b/${quotedMatch[2] ?? ""}"`)
+	};
+	const plainMatch = /^a\/(.+?) b\/(.+)$/.exec(rest);
+	if (plainMatch) return {
+		oldPath: decodeGitPatchPathToken(`a/${plainMatch[1] ?? ""}`),
+		newPath: decodeGitPatchPathToken(`b/${plainMatch[2] ?? ""}`)
+	};
+	return {
+		oldPath: null,
+		newPath: null
+	};
+}
+function splitTrackedPatchBlocks(stdout) {
+	const lines = splitPatchLines(stdout);
+	const blocks = [];
+	let current = [];
+	for (const line of lines) {
+		if (line.startsWith("diff --git ")) {
+			if (current.length > 0) blocks.push(current.join("\n"));
+			current = [line];
+			continue;
+		}
+		if (current.length > 0) current.push(line);
+	}
+	if (current.length > 0) blocks.push(current.join("\n"));
+	return blocks;
+}
+function resolveTrackedPatchBlockIdentity(block) {
+	const lines = splitPatchLines(block);
+	const pathCandidates = /* @__PURE__ */ new Set();
+	const fileIdCandidates = /* @__PURE__ */ new Set();
+	let oldPath = null;
+	let newPath = null;
+	let renameFrom = null;
+	let renameTo = null;
+	const headerLine = lines[0];
+	if (headerLine?.startsWith("diff --git ")) {
+		const parsed = parseDiffGitHeaderPaths(headerLine);
+		oldPath = parsed.oldPath;
+		newPath = parsed.newPath;
+	}
+	for (const line of lines) {
+		if (line.startsWith("rename from ") || line.startsWith("copy from ")) {
+			renameFrom = normalizeGitPath(line.slice(line.indexOf(" from ") + 6).trim());
+			continue;
+		}
+		if (line.startsWith("rename to ") || line.startsWith("copy to ")) {
+			renameTo = normalizeGitPath(line.slice(line.indexOf(" to ") + 4).trim());
+			continue;
+		}
+		if (line.startsWith("--- ")) {
+			oldPath = decodeGitPatchPathToken(line.slice(4));
+			continue;
+		}
+		if (line.startsWith("+++ ")) newPath = decodeGitPatchPathToken(line.slice(4));
+	}
+	if (renameFrom) oldPath = renameFrom;
+	if (renameTo) newPath = renameTo;
+	if (newPath) {
+		pathCandidates.add(newPath);
+		fileIdCandidates.add(createGitFileId(newPath, null));
+	}
+	if (oldPath) {
+		pathCandidates.add(oldPath);
+		fileIdCandidates.add(createGitFileId(oldPath, null));
+	}
+	if (newPath && oldPath && newPath !== oldPath) fileIdCandidates.add(createGitFileId(newPath, oldPath));
+	return {
+		fileIdCandidates: [...fileIdCandidates],
+		pathCandidates: [...pathCandidates]
+	};
+}
+function buildTrackedPatchLookup(files, stdout) {
+	const trackedFiles = files.filter((file) => file.source === "tracked");
+	const fileIds = new Set(trackedFiles.map((file) => file.fileId));
+	const fileIdsByPath = /* @__PURE__ */ new Map();
+	for (const file of trackedFiles) {
+		const pathCandidates = new Set([file.path]);
+		if (file.previousPath) pathCandidates.add(file.previousPath);
+		for (const path of pathCandidates) {
+			const current = fileIdsByPath.get(path) ?? [];
+			current.push(file.fileId);
+			fileIdsByPath.set(path, current);
+		}
+	}
+	const patchByFileId = /* @__PURE__ */ new Map();
+	for (const block of splitTrackedPatchBlocks(stdout)) {
+		const identity = resolveTrackedPatchBlockIdentity(block);
+		let matchedFileId = identity.fileIdCandidates.find((fileId) => fileIds.has(fileId)) ?? null;
+		if (!matchedFileId) for (const path of identity.pathCandidates) {
+			const candidates = fileIdsByPath.get(path);
+			if (!candidates || candidates.length === 0) continue;
+			matchedFileId = candidates.find((fileId) => !patchByFileId.has(fileId)) ?? candidates[0] ?? null;
+			if (matchedFileId) break;
+		}
+		if (matchedFileId && !patchByFileId.has(matchedFileId)) patchByFileId.set(matchedFileId, block.trimEnd());
+	}
+	return patchByFileId;
+}
+function buildTrackedPatchFile(file, rawPatch, available) {
+	const normalized = normalizePatchState(rawPatch ?? "");
+	return {
+		...file,
+		patch: available ? normalized.patch : null,
+		state: available ? normalized.state : "unavailable"
+	};
+}
+function countPatchLines(file) {
+	return file.patch ? splitPatchLines(file.patch).length : 0;
+}
+function projectGitEntryFiles(snapshot, eagerPatchLineBudget) {
+	if (eagerPatchLineBudget <= 0) return {
+		files: snapshot.files,
+		eagerFiles: [],
+		eagerPatchLineBudget,
+		eagerPatchLineCount: 0
+	};
+	const eagerFiles = [];
+	let eagerPatchLineCount = 0;
+	for (const file of snapshot.files) {
+		if (eagerPatchLineCount >= eagerPatchLineBudget) break;
+		const patch = snapshot.patchByFileId.get(file.fileId);
+		if (!patch) continue;
+		eagerFiles.push(patch);
+		eagerPatchLineCount += countPatchLines(patch);
+	}
+	return {
+		files: snapshot.files,
+		eagerFiles,
+		eagerPatchLineBudget,
+		eagerPatchLineCount
+	};
+}
+async function buildGitEntrySnapshot(options) {
+	const runGit = options.runGit ?? defaultRunGit;
+	const resolvedProjectDir = resolve(options.projectDir);
+	const shell = await loadGitEntryShell({
+		...options,
+		projectDir: resolvedProjectDir
+	});
+	if (!shell.entry) return {
+		entry: null,
+		files: [],
+		patchByFileId: /* @__PURE__ */ new Map()
+	};
+	const trackedFiles = shell.files.filter((file) => file.source === "tracked");
+	const trackedPatchPromise = trackedFiles.length > 0 ? runGit(resolvedProjectDir, buildTrackedPatchArgs(options.selector)) : Promise.resolve({
+		ok: true,
+		stdout: ""
+	});
+	const untrackedPatchPromise = Promise.all(shell.files.filter((file) => file.source === "untracked").map(async (file) => [file.fileId, await buildUntrackedPatchFile(resolvedProjectDir, file)]));
+	const [trackedPatchResult, untrackedPatches] = await Promise.all([trackedPatchPromise, untrackedPatchPromise]);
+	const trackedPatchLookup = trackedPatchResult.ok ? buildTrackedPatchLookup(shell.files, trackedPatchResult.stdout) : /* @__PURE__ */ new Map();
+	const patchByFileId = new Map(untrackedPatches);
+	for (const file of trackedFiles) patchByFileId.set(file.fileId, buildTrackedPatchFile(file, trackedPatchLookup.get(file.fileId) ?? null, trackedPatchResult.ok));
+	return {
+		entry: shell.entry,
+		files: shell.files,
+		patchByFileId
+	};
+}
 async function buildGitWorktreeOverview(options) {
 	const resolvedProjectDir = resolve(options.projectDir);
 	return getCachedGitPanelValue("overview", resolvedProjectDir, "overview", async () => {
@@ -1757,52 +1951,32 @@ async function listCurrentWorktreeGitEntries(options) {
 }
 async function getCurrentWorktreeGitEntryShell(options) {
 	const resolvedProjectDir = resolve(options.projectDir);
-	return getCachedGitPanelValue("shell", resolvedProjectDir, options.selector.type === "commit" ? `commit:${options.selector.hash}` : "uncommitted", () => loadGitEntryShell({
+	return getCachedGitPanelValue("shell", resolvedProjectDir, buildSelectorCacheKey(options.selector), () => loadGitEntryShell({
 		...options,
 		projectDir: resolvedProjectDir
 	}));
 }
-async function getCurrentWorktreeGitEntryPatch(options) {
+async function getCurrentWorktreeGitEntryMeta(options) {
 	const resolvedProjectDir = resolve(options.projectDir);
-	return getCachedGitPanelValue("patch", resolvedProjectDir, `${options.selector.type === "commit" ? `commit:${options.selector.hash}` : "uncommitted"}:${options.fileId}`, async () => {
-		const runGit = options.runGit ?? defaultRunGit;
-		const shell = await getCurrentWorktreeGitEntryShell({
+	return getCachedGitPanelValue("meta", resolvedProjectDir, buildSelectorCacheKey(options.selector), async () => {
+		return (await getCurrentWorktreeGitEntryShell({
 			...options,
 			projectDir: resolvedProjectDir
-		});
-		const file = shell.files.find((candidate) => candidate.fileId === options.fileId) ?? null;
-		if (!shell.entry || !file) return {
-			entry: shell.entry,
-			file: null
-		};
-		const patch = file.source === "untracked" ? await buildUntrackedPatchFile(resolvedProjectDir, file) : await buildTrackedPatchFile({
-			worktreePath: resolvedProjectDir,
-			file,
-			runGit,
-			selector: options.selector
-		});
-		return {
-			entry: shell.entry,
-			file: patch
-		};
+		})).entry;
 	});
 }
-async function getCurrentWorktreeGitEntryDetail(options) {
-	const shell = await getCurrentWorktreeGitEntryShell(options);
-	if (!shell.entry) return {
-		entry: null,
-		files: []
-	};
-	const patches = await Promise.all(shell.files.map(async (file) => {
-		return (await getCurrentWorktreeGitEntryPatch({
-			...options,
-			fileId: file.fileId
-		})).file;
+async function getCurrentWorktreeGitEntrySnapshot(options) {
+	const resolvedProjectDir = resolve(options.projectDir);
+	return getCachedGitPanelValue("snapshot", resolvedProjectDir, buildSelectorCacheKey(options.selector), () => buildGitEntrySnapshot({
+		...options,
+		projectDir: resolvedProjectDir
 	}));
-	return {
-		entry: shell.entry,
-		files: patches.filter((file) => file !== null)
-	};
+}
+async function getCurrentWorktreeGitEntryFiles(options) {
+	return projectGitEntryFiles(await getCurrentWorktreeGitEntrySnapshot(options), options.eagerPatchLineBudget);
+}
+async function getCurrentWorktreeGitEntryPatch(options) {
+	return { file: (await getCurrentWorktreeGitEntrySnapshot(options)).patchByFileId.get(options.fileId) ?? null };
 }
 
 //#endregion
@@ -2317,18 +2491,20 @@ const configRouter = router({
 		codeEditor: z.object({ theme: CodeEditorThemeSchema.optional() }).optional(),
 		appBaseUrl: z.string().optional(),
 		terminal: TerminalConfigSchema.omit({ rendererEngine: true }).partial().extend({ rendererEngine: TerminalRendererEngineSchema.optional() }).optional(),
-		dashboard: DashboardConfigSchema.partial().optional()
+		dashboard: DashboardConfigSchema.partial().optional(),
+		git: GitConfigSchema.partial().optional()
 	})).mutation(async ({ ctx, input }) => {
 		const hasCliCommand = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "command");
 		const hasCliArgs = input.cli !== void 0 && Object.prototype.hasOwnProperty.call(input.cli, "args");
 		if (hasCliCommand && !hasCliArgs) {
 			await ctx.configManager.setCliCommand(input.cli?.command ?? "");
-			if (input.theme !== void 0 || input.codeEditor !== void 0 || input.appBaseUrl !== void 0 || input.terminal !== void 0 || input.dashboard !== void 0) await ctx.configManager.writeConfig({
+			if (input.theme !== void 0 || input.codeEditor !== void 0 || input.appBaseUrl !== void 0 || input.terminal !== void 0 || input.dashboard !== void 0 || input.git !== void 0) await ctx.configManager.writeConfig({
 				theme: input.theme,
 				codeEditor: input.codeEditor,
 				appBaseUrl: input.appBaseUrl,
 				terminal: input.terminal,
-				dashboard: input.dashboard
+				dashboard: input.dashboard,
+				git: input.git
 			});
 			return { success: true };
 		}
@@ -2893,16 +3069,18 @@ const gitRouter = router({
 			limit: input?.limit
 		});
 	}),
-	getEntryDetail: publicProcedure.input(z.object({ selector: gitEntrySelectorSchema })).query(async ({ ctx, input }) => {
-		return getCurrentWorktreeGitEntryDetail({
+	getEntryMeta: publicProcedure.input(z.object({ selector: gitEntrySelectorSchema })).query(async ({ ctx, input }) => {
+		return getCurrentWorktreeGitEntryMeta({
 			projectDir: ctx.projectDir,
 			selector: input.selector
 		});
 	}),
-	getEntryShell: publicProcedure.input(z.object({ selector: gitEntrySelectorSchema })).query(async ({ ctx, input }) => {
-		return getCurrentWorktreeGitEntryShell({
+	getEntryFiles: publicProcedure.input(z.object({ selector: gitEntrySelectorSchema })).query(async ({ ctx, input }) => {
+		const config = await ctx.configManager.readConfig();
+		return getCurrentWorktreeGitEntryFiles({
 			projectDir: ctx.projectDir,
-			selector: input.selector
+			selector: input.selector,
+			eagerPatchLineBudget: config.git.diffEagerLineBudget
 		});
 	}),
 	getEntryPatch: publicProcedure.input(z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openspecui/server",
-  "version": "2.2.0",
+  "version": "2.3.3",
   "type": "module",
   "main": "dist/index.mjs",
   "exports": {
@@ -37,7 +37,7 @@
     "tsdown": "^0.16.6",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.0"
   },
   "repository": {
     "type": "git",