jj-plus 0.10.10

package/dist/extension/timeline-service.cjs

@@ -0,0 +1,1154 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+require("./constants.cjs");
+const require_blame = require("../shared/blame.cjs");
+const require_history_adapters = require("./history-adapters.cjs");
+const require_line_history = require("../shared/line-history.cjs");
+const require_non_textual_details = require("../shared/non-textual-details.cjs");
+const require_diff_stats = require("../shared/diff-stats.cjs");
+const require_history_search = require("../shared/history-search.cjs");
+const require_file_oplog = require("../shared/file-oplog.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_fs_promises = require("node:fs/promises");
+//#region src/extension/timeline-service.ts
+const DEFAULT_TIMELINE_PREFERENCES = {
+	sidebarWidth: 276,
+	sidebarCollapsed: false,
+	timelinePaneHeight: 220,
+	timelinePaneCollapsed: false,
+	layoutMode: "split",
+	contentMode: "diffs",
+	comparisonMode: "range",
+	comparisonSource: "revision",
+	showIntermediateRevisions: false,
+	preset: "year",
+	customRevset: "",
+	themePreference: "auto",
+	heatmapOpen: false,
+	lineDiffType: "word-alt"
+};
+const IGNORED_WORKSPACE_DIRECTORIES = /* @__PURE__ */ new Set([
+	".git",
+	".jj",
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	"coverage"
+]);
+function getComparisonEntries(request) {
+	const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+	const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+	const fromEntry = request.entries[normalizedFromIndex];
+	const toEntry = request.entries[normalizedToIndex];
+	if (!fromEntry || !toEntry) return;
+	return {
+		fromEntry,
+		toEntry
+	};
+}
+function syncSession(request) {
+	request.target.adapter = request.source.adapter;
+	request.target.backend = request.source.backend;
+	request.target.workspacePath = request.source.workspacePath;
+	request.target.relativePath = request.source.relativePath;
+	request.target.absolutePath = request.source.absolutePath;
+	request.target.fileName = request.source.fileName;
+	request.target.entries = request.source.entries;
+	request.target.snapshotEntries = request.source.snapshotEntries;
+	request.target.snapshotLoadedChangeIds = request.source.snapshotLoadedChangeIds;
+	request.target.snapshotPendingChangeIds = request.source.snapshotPendingChangeIds;
+	request.target.workspaceFiles = request.source.workspaceFiles;
+	request.target.workspaceFilesLoaded = request.source.workspaceFilesLoaded;
+	request.target.historyLimit = request.source.historyLimit;
+	request.target.intermediateRevisionsLoaded = request.source.intermediateRevisionsLoaded;
+	request.target.contentCache = request.source.contentCache;
+	request.target.previewCache = request.source.previewCache;
+	request.target.rangeOverviewCache = request.source.rangeOverviewCache;
+	request.target.entryDiffCountCache = request.source.entryDiffCountCache;
+	request.target.pathCache = request.source.pathCache;
+	request.target.activeActionAbortController = request.source.activeActionAbortController;
+	request.target.lineHistory = request.source.lineHistory;
+	request.target.customRevset = request.source.customRevset;
+}
+async function getContentForRevset(request) {
+	const cacheKey = `revset:${request.revset}:${request.filePath}`;
+	const cached = request.session.contentCache.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const content = await request.session.adapter.showFileAtRevision({
+		workspacePath: request.session.workspacePath,
+		revset: request.revset,
+		filePath: request.filePath
+	});
+	request.session.contentCache.set(cacheKey, content);
+	return content;
+}
+async function filterSessionEntriesForLineHistory(args) {
+	if (args.adapter.backend === "git") try {
+		const { stdout } = await args.runner.runGit({
+			workspacePath: args.workspacePath,
+			args: require_line_history.buildGitLineHistoryArgs({
+				relativePath: args.relativePath,
+				range: args.range,
+				limit: args.limit
+			})
+		});
+		const revisions = new Set(require_line_history.parseGitLineHistoryRevisions(stdout));
+		const filtered = args.entries.filter((entry) => entry.isWorkingTree || revisions.has(entry.revision));
+		if (filtered.length) return filtered;
+	} catch {}
+	const contentByRevision = /* @__PURE__ */ new Map();
+	for (const entry of args.entries) {
+		const filePath = entry.filePath || args.relativePath;
+		const revset = entry.isWorkingTree ? "@" : entry.revision;
+		try {
+			const content = await args.adapter.showFileAtRevision({
+				workspacePath: args.workspacePath,
+				revset: entry.isWorkingTree && args.adapter.backend === "git" ? "HEAD" : revset,
+				filePath
+			});
+			contentByRevision.set(entry.revision, content);
+		} catch {
+			contentByRevision.set(entry.revision, "");
+		}
+	}
+	if (args.adapter.backend === "git") {
+		const tip = args.entries.find((entry) => entry.isWorkingTree);
+		if (tip) try {
+			const diskPath = node_path.default.join(args.workspacePath, tip.filePath || args.relativePath);
+			contentByRevision.set(tip.revision, await (0, node_fs_promises.readFile)(diskPath, "utf8"));
+		} catch {}
+	}
+	return require_line_history.filterEntriesTouchingLineRange({
+		entries: args.entries,
+		range: args.range,
+		getContent: (entry) => contentByRevision.get(entry.revision) || ""
+	});
+}
+async function hydrateEntryFilePaths(args) {
+	if (!args.entries.length) return;
+	args.entries[args.entries.length - 1].filePath = args.relativePath;
+	let currentPath = args.relativePath;
+	for (let index = args.entries.length - 1; index > 0; index -= 1) {
+		const currentEntry = args.entries[index];
+		const previousEntry = args.entries[index - 1];
+		if (previousEntry.filePath) {
+			currentPath = previousEntry.filePath;
+			continue;
+		}
+		let previousPath = currentPath;
+		if (currentEntry.touchesFile && !currentEntry.isWorkingTree) previousPath = await args.adapter.resolvePreviousPath({
+			workspacePath: args.workspacePath,
+			revision: currentEntry.revision,
+			currentPath
+		});
+		previousEntry.filePath = previousPath;
+		currentPath = previousPath;
+	}
+}
+async function resolvePreviousPathAcrossRevision(request) {
+	const cacheKey = `${request.entry.revision}:${request.currentPath}`;
+	const cached = request.session.pathCache.get(cacheKey);
+	if (cached) return cached;
+	const previousPath = await request.session.adapter.resolvePreviousPath({
+		workspacePath: request.session.workspacePath,
+		revision: request.entry.revision,
+		currentPath: request.currentPath
+	});
+	request.session.pathCache.set(cacheKey, previousPath);
+	return previousPath;
+}
+async function loadRevisionTreeFiles(request) {
+	const revision = request.revision.trim() || "@";
+	try {
+		return await request.session.adapter.listRevisionTreeFiles({
+			workspacePath: request.session.workspacePath,
+			revision
+		});
+	} catch {
+		return [];
+	}
+}
+function createTimelineService(args) {
+	const { runner } = args;
+	return {
+		buildSession,
+		buildPayload,
+		mapEntriesForPayload,
+		ensureWorkspaceFiles,
+		loadRevisionTreeFiles,
+		ensureIntermediateRevisions,
+		expandFileHistory,
+		findNearestNonEmptyVisibleRange,
+		getComparisonEntries,
+		getDiffPreview,
+		getDiffBlame,
+		getFileOpLog,
+		searchFileHistory,
+		getEntryDiffCounts,
+		getEntriesForSource,
+		getRangeOverview,
+		getRangeStackPreviews,
+		hydrateSnapshotEntries,
+		resolveBlameRevisionForLine,
+		runSessionAction,
+		resolveEntryFilePath,
+		syncSession
+	};
+	async function buildSession(request) {
+		const historyWorkspacePath = await require_history_adapters.resolveHistoryWorkspacePath({
+			workspacePath: request.workspacePath,
+			runner
+		});
+		const relativePath = node_path.default.relative(historyWorkspacePath, request.absolutePath).replace(/\\/g, "/");
+		const adapter = await require_history_adapters.resolveHistoryAdapter({
+			workspacePath: historyWorkspacePath,
+			runner
+		});
+		const entryLimit = request.options?.entryLimit ?? 50;
+		const includeWorkspaceFiles = request.options?.includeWorkspaceFiles === true;
+		const includeIntermediateRevisions = request.options?.includeIntermediateRevisions === true;
+		const lineHistory = request.options?.lineHistory ? require_line_history.normalizeLineHistoryRange(request.options.lineHistory.startLine, request.options.lineHistory.endLine) : null;
+		const customRevset = (request.options?.customRevset || "").trim() || void 0;
+		const workspaceFiles = includeWorkspaceFiles ? await listWorkspaceFiles({
+			adapter,
+			workspacePath: historyWorkspacePath
+		}) : [relativePath];
+		const fileEntries = await adapter.getFileRevisionHistory({
+			workspacePath: historyWorkspacePath,
+			relativePath,
+			limit: entryLimit,
+			customRevset
+		});
+		let entries = await buildTimelineEntries({
+			adapter,
+			workspacePath: historyWorkspacePath,
+			absolutePath: request.absolutePath,
+			relativePath,
+			fileEntries,
+			includeIntermediateRevisions,
+			entryLimit
+		});
+		if (lineHistory) entries = await filterSessionEntriesForLineHistory({
+			adapter,
+			runner,
+			workspacePath: historyWorkspacePath,
+			relativePath,
+			entries,
+			range: lineHistory,
+			limit: entryLimit
+		});
+		const snapshotEntries = adapter.backend === "jj" ? [] : [...entries];
+		const remoteBaseUrl = await adapter.getRemoteBaseUrl({ workspacePath: historyWorkspacePath });
+		if (remoteBaseUrl) {
+			for (const entry of entries) if (!entry.isWorkingTree) entry.remoteUrl = `${remoteBaseUrl}/commit/${entry.revision}`;
+		}
+		await hydrateEntryFilePaths({
+			adapter,
+			workspacePath: historyWorkspacePath,
+			relativePath,
+			entries
+		});
+		return {
+			adapter,
+			backend: adapter.backend,
+			workspacePath: historyWorkspacePath,
+			absolutePath: request.absolutePath,
+			relativePath,
+			fileName: node_path.default.basename(request.absolutePath),
+			entries,
+			snapshotEntries,
+			snapshotLoadedChangeIds: /* @__PURE__ */ new Set(),
+			snapshotPendingChangeIds: /* @__PURE__ */ new Set(),
+			workspaceFiles,
+			workspaceFilesLoaded: includeWorkspaceFiles,
+			historyLimit: entryLimit,
+			intermediateRevisionsLoaded: includeIntermediateRevisions,
+			lineHistory: lineHistory ?? void 0,
+			customRevset,
+			contentCache: /* @__PURE__ */ new Map(),
+			previewCache: /* @__PURE__ */ new Map(),
+			rangeOverviewCache: /* @__PURE__ */ new Map(),
+			entryDiffCountCache: /* @__PURE__ */ new Map(),
+			pathCache: /* @__PURE__ */ new Map(),
+			activeActionAbortController: void 0
+		};
+	}
+	function mapEntriesForPayload(entries) {
+		return entries.map((entry, index) => ({
+			...entry,
+			index,
+			hasPreviousEntry: index > 0,
+			monthLabel: formatEntryMonthLabel(entry.authorDate),
+			shortDate: formatEntryShortDate(entry.authorDate),
+			relativeDate: formatRelativeTime(entry.timestamp)
+		}));
+	}
+	function buildPayload(request) {
+		return {
+			backend: request.session.backend,
+			workspacePath: request.session.workspacePath,
+			relativePath: request.session.relativePath,
+			fileName: request.session.fileName,
+			version: request.version,
+			presets: request.presets,
+			defaultIndex: Math.max(0, request.session.entries.length - 1),
+			latestIndex: Math.max(0, request.session.entries.length - 1),
+			preferences: normalizeTimelinePreferences(request.preferences),
+			workspaceFiles: request.session.workspaceFiles,
+			workspaceFilesLoaded: request.session.workspaceFilesLoaded,
+			hasIntermediateRevisions: request.session.entries.some((entry) => !entry.touchesFile),
+			entries: mapEntriesForPayload(request.session.entries),
+			snapshotEntries: mapEntriesForPayload(request.session.snapshotEntries),
+			snapshotState: { loadedChangeIds: [...request.session.snapshotLoadedChangeIds] },
+			...request.session.lineHistory ? { lineHistory: request.session.lineHistory } : {},
+			...request.session.customRevset ? { customRevset: request.session.customRevset } : {}
+		};
+	}
+	async function ensureWorkspaceFiles(request) {
+		if (request.session.workspaceFilesLoaded) return false;
+		const workspaceFiles = await listWorkspaceFiles({
+			adapter: request.session.adapter,
+			workspacePath: request.session.workspacePath
+		});
+		request.session.workspaceFiles = workspaceFiles;
+		request.session.workspaceFilesLoaded = true;
+		request.session.rangeOverviewCache.clear();
+		return true;
+	}
+	async function ensureIntermediateRevisions(request) {
+		if (request.session.intermediateRevisionsLoaded) return false;
+		const touchingEntries = request.session.entries.filter((entry) => entry.touchesFile && !entry.isWorkingTree);
+		if (touchingEntries.length < 2) {
+			request.session.intermediateRevisionsLoaded = true;
+			return false;
+		}
+		try {
+			const repositoryEntries = await request.session.adapter.getRepositoryRevisionHistory({
+				workspacePath: request.session.workspacePath,
+				limit: 200
+			});
+			const workingTreeEntry = request.session.entries.find((entry) => entry.isWorkingTree);
+			let entries = mergeTimelineEntries({
+				repositoryEntries,
+				fileEntries: touchingEntries
+			});
+			if (request.session.backend === "jj") entries = dedupeAdjacentTimelineEntries(entries);
+			if (workingTreeEntry) entries = [...entries, workingTreeEntry];
+			request.session.entries = entries;
+			request.session.intermediateRevisionsLoaded = true;
+			request.session.previewCache.clear();
+			request.session.rangeOverviewCache.clear();
+			request.session.entryDiffCountCache.clear();
+			return true;
+		} catch {
+			request.session.intermediateRevisionsLoaded = true;
+			return false;
+		}
+	}
+	async function expandFileHistory(request) {
+		if (request.session.historyLimit >= 200) return false;
+		const previousTouchingCount = request.session.entries.filter((entry) => entry.touchesFile && !entry.isWorkingTree).length;
+		if (previousTouchingCount < request.session.historyLimit) {
+			request.session.historyLimit = 200;
+			return false;
+		}
+		const fileEntries = await request.session.adapter.getFileRevisionHistory({
+			workspacePath: request.session.workspacePath,
+			relativePath: request.session.relativePath,
+			limit: 200
+		});
+		const entries = await buildTimelineEntries({
+			adapter: request.session.adapter,
+			workspacePath: request.session.workspacePath,
+			absolutePath: request.session.absolutePath,
+			relativePath: request.session.relativePath,
+			fileEntries,
+			includeIntermediateRevisions: request.session.intermediateRevisionsLoaded,
+			entryLimit: 200
+		});
+		const nextTouchingCount = entries.filter((entry) => entry.touchesFile && !entry.isWorkingTree).length;
+		request.session.entries = entries;
+		request.session.historyLimit = 200;
+		request.session.previewCache.clear();
+		request.session.rangeOverviewCache.clear();
+		request.session.entryDiffCountCache.clear();
+		return nextTouchingCount > previousTouchingCount;
+	}
+	function getEntriesForSource(request) {
+		if (request.session.backend !== "jj" || request.comparisonSource !== "snapshot") return request.session.entries;
+		return composeSnapshotEntries({
+			revisionEntries: request.session.entries,
+			snapshotEntries: request.session.snapshotEntries,
+			loadedChangeIds: request.session.snapshotLoadedChangeIds
+		});
+	}
+	async function getDiffPreview(request) {
+		const comparisonSource = request.comparisonSource || "revision";
+		const sourceEntries = getEntriesForSource({
+			session: request.session,
+			comparisonSource
+		});
+		const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+		const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+		const cacheKey = `${comparisonSource}:${normalizedFromIndex}:${normalizedToIndex}`;
+		const cached = request.session.previewCache.get(cacheKey);
+		if (cached) return cached;
+		if (request.session.backend === "jj" && comparisonSource === "snapshot") {
+			const preview = await getJjSnapshotPreview({
+				session: request.session,
+				fromIndex: normalizedFromIndex,
+				toIndex: normalizedToIndex
+			});
+			request.session.previewCache.set(cacheKey, preview);
+			return preview;
+		}
+		const comparison = getComparisonEntries({
+			entries: sourceEntries,
+			fromIndex: normalizedFromIndex,
+			toIndex: normalizedToIndex
+		});
+		if (!comparison) return createEmptyPreview({
+			index: normalizedToIndex,
+			fromIndex: normalizedFromIndex,
+			toIndex: normalizedToIndex,
+			comparisonSource,
+			title: "No revision selected"
+		});
+		const beforePath = comparison.fromEntry ? await resolveEntryFilePath({
+			session: request.session,
+			entry: comparison.fromEntry,
+			entryIndex: normalizedFromIndex
+		}) : "";
+		const afterPath = await resolveEntryFilePath({
+			session: request.session,
+			entry: comparison.toEntry,
+			entryIndex: normalizedToIndex
+		});
+		const beforeText = comparison.fromEntry ? await getRevisionContent({
+			session: request.session,
+			entry: comparison.fromEntry,
+			entryIndex: normalizedFromIndex
+		}) : "";
+		const afterText = await getRevisionContent({
+			session: request.session,
+			entry: comparison.toEntry,
+			entryIndex: normalizedToIndex
+		});
+		const preview = buildDiffPreview({
+			index: normalizedToIndex,
+			previousEntry: comparison.fromEntry,
+			currentEntry: comparison.toEntry,
+			beforeText,
+			afterText,
+			fromIndex: normalizedFromIndex,
+			toIndex: normalizedToIndex,
+			beforePath,
+			afterPath,
+			comparisonSource
+		});
+		request.session.previewCache.set(cacheKey, preview);
+		return preview;
+	}
+	async function hydrateSnapshotEntries(request) {
+		if (request.session.backend !== "jj") return false;
+		const uniqueTargets = request.revisionIndexes.map((index) => request.session.entries[index]).filter((entry) => Boolean(entry && !entry.isWorkingTree && entry.touchesFile && entry.changeId && !request.session.snapshotLoadedChangeIds.has(entry.changeId) && !request.session.snapshotPendingChangeIds.has(entry.changeId))).reduce((entries, entry) => {
+			if (!entry.changeId || entries.some((candidate) => candidate.changeId === entry.changeId)) return entries;
+			entries.push(entry);
+			return entries;
+		}, []).slice(-8);
+		if (!uniqueTargets.length) return false;
+		let didUpdate = false;
+		for (const entry of uniqueTargets) {
+			const changeId = entry.changeId;
+			if (!changeId) continue;
+			request.session.snapshotPendingChangeIds.add(changeId);
+			const expandedEntries = await request.session.adapter.getSnapshotEntriesForFile({
+				workspacePath: request.session.workspacePath,
+				relativePath: request.session.relativePath,
+				entry
+			});
+			request.session.snapshotPendingChangeIds.delete(changeId);
+			request.session.snapshotLoadedChangeIds.add(changeId);
+			if (expandedEntries.length) {
+				request.session.snapshotEntries.push(...expandedEntries);
+				didUpdate = true;
+			}
+		}
+		if (!didUpdate) return true;
+		request.session.snapshotEntries = request.session.snapshotEntries.toSorted((left, right) => left.timestamp - right.timestamp || left.revision.localeCompare(right.revision));
+		for (const cacheKey of request.session.previewCache.keys()) if (cacheKey.startsWith("snapshot:")) request.session.previewCache.delete(cacheKey);
+		for (const cacheKey of request.session.rangeOverviewCache.keys()) if (cacheKey.startsWith("snapshot:")) request.session.rangeOverviewCache.delete(cacheKey);
+		for (const cacheKey of request.session.entryDiffCountCache.keys()) if (cacheKey.startsWith("snapshot:")) request.session.entryDiffCountCache.delete(cacheKey);
+		return true;
+	}
+	async function findNearestNonEmptyVisibleRange(request) {
+		if (request.candidateIndexes.length < 2) return null;
+		for (let index = request.candidateIndexes.length - 1; index > 0; index -= 1) {
+			const fromIndex = request.candidateIndexes[index - 1];
+			const toIndex = request.candidateIndexes[index];
+			if ((await getDiffPreview({
+				session: request.session,
+				fromIndex,
+				toIndex
+			})).hasChanges) return {
+				fromIndex,
+				toIndex
+			};
+		}
+		return null;
+	}
+	async function getRangeOverview(request) {
+		const comparisonSource = request.comparisonSource || "revision";
+		const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+		const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+		const selectedEntryIndexes = (request.selectedEntryIndexes || []).filter((value) => Number.isInteger(value));
+		const cacheKey = `${comparisonSource}:${normalizedFromIndex}:${normalizedToIndex}:${selectedEntryIndexes.length ? selectedEntryIndexes.join(",") : "all"}`;
+		const cached = request.session.rangeOverviewCache.get(cacheKey);
+		if (cached) return cached;
+		const sourceEntries = getEntriesForSource({
+			session: request.session,
+			comparisonSource
+		});
+		const countedPaths = /* @__PURE__ */ new Map();
+		if (!request.session.workspaceFilesLoaded) await ensureWorkspaceFiles({ session: request.session });
+		const workspaceFileSet = new Set(request.session.workspaceFiles);
+		const entryIndexesToScan = selectedEntryIndexes.length ? selectedEntryIndexes : Array.from({ length: normalizedToIndex - normalizedFromIndex }, (_, index) => normalizedFromIndex + index + 1);
+		for (const index of entryIndexesToScan) {
+			const entry = sourceEntries[index];
+			if (!entry) continue;
+			const changedFiles = entry.isWorkingTree ? await request.session.adapter.listWorkingTreeFiles({ workspacePath: request.session.workspacePath }) : await request.session.adapter.listRevisionFiles({
+				workspacePath: request.session.workspacePath,
+				revision: entry.revision
+			});
+			for (const relativePath of changedFiles) {
+				if (!relativePath || !workspaceFileSet.has(relativePath) && relativePath !== request.session.relativePath) continue;
+				countedPaths.set(relativePath, (countedPaths.get(relativePath) || 0) + 1);
+			}
+		}
+		const items = [...countedPaths.entries()].map(([relativePath, changeCount]) => ({
+			relativePath,
+			changeCount,
+			isCurrentFile: relativePath === request.session.relativePath
+		})).toSorted((left, right) => {
+			if (left.changeCount !== right.changeCount) return right.changeCount - left.changeCount;
+			if (left.isCurrentFile !== right.isCurrentFile) return Number(right.isCurrentFile) - Number(left.isCurrentFile);
+			return left.relativePath.localeCompare(right.relativePath);
+		}).slice(0, 150);
+		request.session.rangeOverviewCache.set(cacheKey, items);
+		return items;
+	}
+	async function getRangeStackPreviews(request) {
+		const comparisonSource = request.comparisonSource || "revision";
+		const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+		const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+		const comparison = getComparisonEntries({
+			entries: getEntriesForSource({
+				session: request.session,
+				comparisonSource
+			}),
+			fromIndex: normalizedFromIndex,
+			toIndex: normalizedToIndex
+		});
+		if (!comparison) return [];
+		const items = [];
+		for (const relativePath of request.relativePaths) {
+			const trimmed = relativePath.trim();
+			if (!trimmed) continue;
+			if (trimmed === request.session.relativePath) {
+				items.push({
+					relativePath: trimmed,
+					preview: await getDiffPreview({
+						session: request.session,
+						fromIndex: normalizedFromIndex,
+						toIndex: normalizedToIndex,
+						comparisonSource
+					})
+				});
+				continue;
+			}
+			const beforeText = comparison.fromEntry ? await readPathAtEntry({
+				session: request.session,
+				entry: comparison.fromEntry,
+				relativePath: trimmed
+			}) : "";
+			const afterText = await readPathAtEntry({
+				session: request.session,
+				entry: comparison.toEntry,
+				relativePath: trimmed
+			});
+			items.push({
+				relativePath: trimmed,
+				preview: buildDiffPreview({
+					index: normalizedToIndex,
+					previousEntry: comparison.fromEntry,
+					currentEntry: comparison.toEntry,
+					beforeText,
+					afterText,
+					fromIndex: normalizedFromIndex,
+					toIndex: normalizedToIndex,
+					beforePath: trimmed,
+					afterPath: trimmed,
+					comparisonSource
+				})
+			});
+		}
+		return items;
+	}
+	async function readPathAtEntry(request) {
+		const cacheKey = `${request.entry.id}:stack:${request.relativePath}`;
+		const cached = request.session.contentCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		try {
+			const content = request.entry.isWorkingTree ? await (0, node_fs_promises.readFile)(node_path.default.join(request.session.workspacePath, request.relativePath), "utf8") : await request.session.adapter.showFileAtRevision({
+				workspacePath: request.session.workspacePath,
+				revset: request.entry.revision,
+				filePath: request.relativePath
+			});
+			request.session.contentCache.set(cacheKey, content);
+			return content;
+		} catch {
+			request.session.contentCache.set(cacheKey, "");
+			return "";
+		}
+	}
+	async function getEntryDiffCounts(request) {
+		const comparisonSource = request.comparisonSource || "revision";
+		const sourceEntries = getEntriesForSource({
+			session: request.session,
+			comparisonSource
+		});
+		return Promise.all(request.entryIndexes.map(async (entryIndex) => {
+			const cacheKey = `${comparisonSource}:${entryIndex}`;
+			const cached = request.session.entryDiffCountCache.get(cacheKey);
+			if (cached !== void 0) return {
+				entryIndex,
+				diffCount: cached
+			};
+			const entry = sourceEntries[entryIndex];
+			if (!entry || entryIndex <= 0) {
+				request.session.entryDiffCountCache.set(cacheKey, 0);
+				return {
+					entryIndex,
+					diffCount: 0
+				};
+			}
+			let diffCount = 0;
+			if (entry.isWorkingTree) {
+				const previousEntry = sourceEntries[entryIndex - 1];
+				if (previousEntry) diffCount = (await request.session.adapter.buildRangeMultiDiffPlan({
+					workspacePath: request.session.workspacePath,
+					fromEntry: previousEntry,
+					toEntry: entry,
+					comparisonSource,
+					sourceEntries
+				})).files.length;
+			} else diffCount = (await request.session.adapter.buildRevisionMultiDiffPlan({
+				workspacePath: request.session.workspacePath,
+				entry,
+				entryIndex,
+				comparisonSource,
+				sourceEntries
+			})).files.length;
+			request.session.entryDiffCountCache.set(cacheKey, diffCount);
+			return {
+				entryIndex,
+				diffCount
+			};
+		}));
+	}
+	async function resolveEntryFilePath(request) {
+		if (request.entry.isWorkingTree) return request.session.relativePath;
+		if (request.entry.filePath) return request.entry.filePath;
+		await ensureEntryFilePath(request);
+		return request.entry.filePath || request.session.relativePath;
+	}
+	async function runSessionAction(request) {
+		request.session.activeActionAbortController?.abort();
+		const controller = new AbortController();
+		request.session.activeActionAbortController = controller;
+		try {
+			await request.action(controller.signal);
+		} catch (error) {
+			if (isAbortError(error) || controller.signal.aborted) return;
+			throw error;
+		} finally {
+			if (request.session.activeActionAbortController === controller) request.session.activeActionAbortController = void 0;
+		}
+	}
+	async function resolveBlameRevisionForLine(request) {
+		try {
+			if (request.backend === "git") {
+				const { stdout } = await runner.runGit({
+					workspacePath: request.workspacePath,
+					args: require_blame.buildGitBlameArgs({
+						relativePath: request.relativePath,
+						line: request.line
+					})
+				});
+				return require_blame.findBlameForLine(require_blame.parseGitBlamePorcelain(stdout), request.line)?.revision;
+			}
+			const { stdout } = await runner.runJj({
+				workspacePath: request.workspacePath,
+				args: require_blame.buildJjAnnotateArgs({ relativePath: request.relativePath })
+			});
+			return require_blame.findBlameForLine(require_blame.parseJjFileAnnotate(stdout), request.line)?.revision;
+		} catch {
+			return;
+		}
+	}
+	async function getDiffBlame(request) {
+		const comparisonSource = request.comparisonSource || "revision";
+		const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+		const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+		const toEntry = getEntriesForSource({
+			session: request.session,
+			comparisonSource
+		})[normalizedToIndex];
+		const relativePath = toEntry?.filePath || request.session.relativePath;
+		if (!toEntry) return {
+			relativePath,
+			lines: []
+		};
+		try {
+			if (request.session.backend === "git") {
+				const { stdout } = await runner.runGit({
+					workspacePath: request.session.workspacePath,
+					args: require_blame.buildGitBlameFileArgs({
+						relativePath,
+						revision: toEntry.isWorkingTree ? void 0 : toEntry.revision
+					})
+				});
+				return {
+					relativePath,
+					lines: require_blame.parseGitBlamePorcelain(stdout)
+				};
+			}
+			const { stdout } = await runner.runJj({
+				workspacePath: request.session.workspacePath,
+				args: require_blame.buildJjAnnotateArgs({
+					relativePath,
+					revision: toEntry.isWorkingTree ? void 0 : toEntry.revision
+				})
+			});
+			return {
+				relativePath,
+				lines: require_blame.parseJjFileAnnotate(stdout)
+			};
+		} catch {
+			return {
+				relativePath,
+				lines: []
+			};
+		}
+	}
+	async function getFileOpLog(request) {
+		const relativePath = request.session.relativePath;
+		if (request.session.backend !== "jj") return {
+			relativePath,
+			entries: []
+		};
+		try {
+			const { stdout } = await runner.runJj({
+				workspacePath: request.session.workspacePath,
+				args: [
+					"op",
+					"log",
+					"--limit",
+					"80",
+					"-T",
+					require_file_oplog.JJ_OP_LOG_TEMPLATE
+				]
+			});
+			const fileEntries = [...request.session.snapshotEntries, ...request.session.entries.filter((entry) => Boolean(entry.operationId))];
+			return {
+				relativePath,
+				entries: require_file_oplog.filterFileOpLogPeek({
+					opLog: require_file_oplog.parseJjOpLogOutput(stdout),
+					fileEntries,
+					relativePath,
+					limit: 12
+				})
+			};
+		} catch {
+			return {
+				relativePath,
+				entries: []
+			};
+		}
+	}
+	async function searchFileHistory(request) {
+		const maxEntries = request.maxEntries ?? 40;
+		const touching = request.session.entries.map((entry, index) => ({
+			entry,
+			index
+		})).filter(({ entry }) => entry.touchesFile && !entry.isWorkingTree).slice(-maxEntries);
+		const contentsByIndex = /* @__PURE__ */ new Map();
+		for (const { entry, index } of touching) try {
+			const content = await getRevisionContent({
+				session: request.session,
+				entry,
+				entryIndex: index
+			});
+			contentsByIndex.set(index, content);
+		} catch {
+			contentsByIndex.set(index, "");
+		}
+		const orderedEntryIndexes = touching.map(({ index }) => index);
+		if (request.purpose === "sidebar") return require_history_search.searchHistoryDiffContents({
+			query: request.query,
+			orderedEntryIndexes,
+			contentsByIndex
+		});
+		return require_history_search.searchHistoryContents({
+			query: request.query,
+			orderedEntryIndexes,
+			contentsByIndex
+		});
+	}
+	async function buildTimelineEntries(request) {
+		const touchingEntries = request.fileEntries.map((entry) => ({
+			...entry,
+			touchesFile: true
+		}));
+		if (touchingEntries.length) touchingEntries[touchingEntries.length - 1].filePath = request.relativePath;
+		let entries = touchingEntries;
+		if (request.includeIntermediateRevisions && touchingEntries.length >= 2) try {
+			entries = mergeTimelineEntries({
+				repositoryEntries: await request.adapter.getRepositoryRevisionHistory({
+					workspacePath: request.workspacePath,
+					limit: Math.max(request.entryLimit, 200)
+				}),
+				fileEntries: touchingEntries
+			});
+		} catch {
+			entries = touchingEntries;
+		}
+		if (request.adapter.backend === "jj") entries = dedupeAdjacentTimelineEntries(entries);
+		return appendWorkingTreeEntry({
+			adapter: request.adapter,
+			workspacePath: request.workspacePath,
+			absolutePath: request.absolutePath,
+			relativePath: request.relativePath,
+			entries
+		});
+	}
+	async function listWorkspaceFiles(request) {
+		if (request.adapter.backend === "git") try {
+			const { stdout } = await runner.runGit({
+				workspacePath: request.workspacePath,
+				args: [
+					"ls-files",
+					"--cached",
+					"-z"
+				]
+			});
+			const files = stdout.split("\0").map((value) => value.trim()).filter(Boolean).toSorted((left, right) => left.localeCompare(right));
+			if (files.length) return files;
+		} catch {}
+		if (request.adapter.backend === "jj") try {
+			const { stdout } = await runner.runJj({
+				workspacePath: request.workspacePath,
+				args: ["file", "list"]
+			});
+			const files = stdout.split(/\r?\n/u).map((value) => value.trim()).filter(Boolean).toSorted((left, right) => left.localeCompare(right));
+			if (files.length) return files;
+		} catch {}
+		const files = [];
+		await collectWorkspaceFiles({
+			workspacePath: request.workspacePath,
+			currentDirectory: request.workspacePath,
+			files
+		});
+		return files.toSorted((left, right) => left.localeCompare(right));
+	}
+	async function collectWorkspaceFiles(request) {
+		const directoryEntries = await (0, node_fs_promises.readdir)(request.currentDirectory, { withFileTypes: true });
+		for (const directoryEntry of directoryEntries) {
+			if (directoryEntry.isDirectory() && IGNORED_WORKSPACE_DIRECTORIES.has(directoryEntry.name)) continue;
+			const absolutePath = node_path.default.join(request.currentDirectory, directoryEntry.name);
+			if (directoryEntry.isDirectory()) {
+				await collectWorkspaceFiles({
+					workspacePath: request.workspacePath,
+					currentDirectory: absolutePath,
+					files: request.files
+				});
+				continue;
+			}
+			if (!directoryEntry.isFile()) continue;
+			request.files.push(node_path.default.relative(request.workspacePath, absolutePath).replace(/\\/g, "/"));
+		}
+	}
+	async function appendWorkingTreeEntry(request) {
+		if (!await runner.fileExists({ filePath: request.absolutePath })) return request.entries;
+		const lastEntry = request.entries.at(-1);
+		const lastTouchingEntry = request.entries.filter((entry) => entry.touchesFile && !entry.isWorkingTree).at(-1);
+		if (lastEntry?.isWorkingTree) return request.entries;
+		if (lastTouchingEntry) {
+			if (await (0, node_fs_promises.readFile)(request.absolutePath, "utf8") === await request.adapter.showFileAtRevision({
+				workspacePath: request.workspacePath,
+				revset: lastTouchingEntry.revision,
+				filePath: lastTouchingEntry.filePath || request.relativePath
+			}) && (lastTouchingEntry.filePath || request.relativePath) === request.relativePath) return request.entries;
+		}
+		const now = /* @__PURE__ */ new Date();
+		return [...request.entries, {
+			id: "working-tree",
+			revision: "WORKTREE",
+			shortRevision: "Current",
+			changeId: void 0,
+			authorDate: now.toISOString(),
+			authorName: "",
+			description: "Working tree",
+			isWorkingTree: true,
+			touchesFile: true,
+			timestamp: now.getTime(),
+			filePath: request.relativePath
+		}];
+	}
+	function composeSnapshotEntries(request) {
+		if (!request.loadedChangeIds.size) return request.revisionEntries;
+		const snapshotEntriesByChangeId = request.snapshotEntries.reduce((groups, entry) => {
+			if (!entry.changeId) return groups;
+			const existing = groups.get(entry.changeId) || [];
+			existing.push(entry);
+			groups.set(entry.changeId, existing);
+			return groups;
+		}, /* @__PURE__ */ new Map());
+		return request.revisionEntries.flatMap((entry) => {
+			if (entry.isWorkingTree || !entry.touchesFile || !entry.changeId || !request.loadedChangeIds.has(entry.changeId)) return [entry];
+			return snapshotEntriesByChangeId.get(entry.changeId) || [entry];
+		});
+	}
+	async function getJjSnapshotPreview(request) {
+		const sourceEntries = getEntriesForSource({
+			session: request.session,
+			comparisonSource: "snapshot"
+		});
+		const normalizedFromIndex = Math.max(0, Math.min(request.fromIndex, request.toIndex));
+		const normalizedToIndex = Math.max(normalizedFromIndex, Math.max(request.fromIndex, request.toIndex));
+		const entry = sourceEntries[normalizedToIndex];
+		if (!entry) return createEmptyPreview({
+			index: normalizedToIndex,
+			fromIndex: normalizedFromIndex,
+			toIndex: normalizedToIndex,
+			comparisonSource: "snapshot",
+			title: "No revision selected"
+		});
+		const afterPath = await resolveEntryFilePath({
+			session: request.session,
+			entry,
+			entryIndex: normalizedToIndex
+		});
+		const previousEntryIndex = normalizedFromIndex === normalizedToIndex ? normalizedToIndex - 1 : normalizedFromIndex;
+		const previousEntry = previousEntryIndex >= 0 ? sourceEntries[previousEntryIndex] : void 0;
+		const previousPath = previousEntry ? await resolveEntryFilePath({
+			session: request.session,
+			entry: previousEntry,
+			entryIndex: previousEntryIndex
+		}) : entry.isWorkingTree ? request.session.relativePath : await resolvePreviousPathAcrossRevision({
+			session: request.session,
+			entry,
+			currentPath: afterPath
+		});
+		return {
+			...buildDiffPreview({
+				index: normalizedToIndex,
+				previousEntry,
+				currentEntry: entry,
+				beforeText: previousEntry ? await getRevisionContent({
+					session: request.session,
+					entry: previousEntry,
+					entryIndex: previousEntryIndex
+				}) : entry.isWorkingTree ? "" : await getContentForRevset({
+					session: request.session,
+					revset: `${entry.revision}-`,
+					filePath: previousPath
+				}),
+				afterText: await getRevisionContent({
+					session: request.session,
+					entry,
+					entryIndex: normalizedToIndex
+				}),
+				fromIndex: normalizedFromIndex,
+				toIndex: normalizedToIndex,
+				beforePath: previousPath,
+				afterPath,
+				comparisonSource: "snapshot"
+			}),
+			title: entry.isWorkingTree ? `Snapshot @ ${entry.shortRevision}` : `Snapshot ${entry.shortRevision}`
+		};
+	}
+	async function getRevisionContent(request) {
+		const resolvedPath = request.entry.isWorkingTree ? request.session.relativePath : await resolveEntryFilePath(request);
+		const cacheKey = `${request.entry.id}:${resolvedPath}`;
+		const cached = request.session.contentCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const content = request.entry.isWorkingTree ? await (0, node_fs_promises.readFile)(request.session.absolutePath, "utf8") : await request.session.adapter.showFileAtRevision({
+			workspacePath: request.session.workspacePath,
+			revset: request.entry.revision,
+			filePath: resolvedPath
+		});
+		request.session.contentCache.set(cacheKey, content);
+		return content;
+	}
+	async function ensureEntryFilePath(request) {
+		const targetEntry = request.session.entries[request.entryIndex];
+		if (!targetEntry || targetEntry.filePath || targetEntry.isWorkingTree) return;
+		let knownIndex = -1;
+		for (let index = request.entryIndex + 1; index < request.session.entries.length; index += 1) if (request.session.entries[index]?.filePath) {
+			knownIndex = index;
+			break;
+		}
+		if (knownIndex < 0) {
+			targetEntry.filePath = request.session.relativePath;
+			return;
+		}
+		let currentPath = request.session.entries[knownIndex].filePath || request.session.relativePath;
+		for (let index = knownIndex; index > request.entryIndex; index -= 1) {
+			const currentEntry = request.session.entries[index];
+			const previousEntry = request.session.entries[index - 1];
+			if (!previousEntry) break;
+			if (!previousEntry.filePath) {
+				let previousPath = currentPath;
+				if (currentEntry.touchesFile && !currentEntry.isWorkingTree) previousPath = await resolvePreviousPathAcrossRevision({
+					session: request.session,
+					entry: currentEntry,
+					currentPath
+				});
+				previousEntry.filePath = previousPath;
+			}
+			currentPath = previousEntry.filePath || currentPath;
+		}
+	}
+}
+function normalizeTimelinePreferences(preferences) {
+	if (!preferences) return { ...DEFAULT_TIMELINE_PREFERENCES };
+	return {
+		sidebarWidth: typeof preferences.sidebarWidth === "number" ? preferences.sidebarWidth : DEFAULT_TIMELINE_PREFERENCES.sidebarWidth,
+		sidebarCollapsed: preferences.sidebarCollapsed === true,
+		timelinePaneHeight: typeof preferences.timelinePaneHeight === "number" ? preferences.timelinePaneHeight : DEFAULT_TIMELINE_PREFERENCES.timelinePaneHeight,
+		timelinePaneCollapsed: preferences.timelinePaneCollapsed === true,
+		layoutMode: preferences.layoutMode === "unified" ? "unified" : DEFAULT_TIMELINE_PREFERENCES.layoutMode,
+		contentMode: preferences.contentMode === "full" ? "full" : DEFAULT_TIMELINE_PREFERENCES.contentMode,
+		comparisonMode: preferences.comparisonMode === "step" ? "step" : DEFAULT_TIMELINE_PREFERENCES.comparisonMode,
+		comparisonSource: preferences.comparisonSource === "snapshot" ? "snapshot" : DEFAULT_TIMELINE_PREFERENCES.comparisonSource,
+		showIntermediateRevisions: preferences.showIntermediateRevisions === true,
+		preset: preferences.preset === "7d" || preferences.preset === "30d" || preferences.preset === "90d" || preferences.preset === "all" || preferences.preset === "year" ? preferences.preset : DEFAULT_TIMELINE_PREFERENCES.preset,
+		customRevset: typeof preferences.customRevset === "string" ? preferences.customRevset.trim() : "",
+		themePreference: preferences.themePreference === "light" || preferences.themePreference === "dark" ? preferences.themePreference : DEFAULT_TIMELINE_PREFERENCES.themePreference,
+		heatmapOpen: preferences.heatmapOpen === true,
+		lineDiffType: preferences.lineDiffType === "word" || preferences.lineDiffType === "char" || preferences.lineDiffType === "none" || preferences.lineDiffType === "word-alt" ? preferences.lineDiffType : DEFAULT_TIMELINE_PREFERENCES.lineDiffType
+	};
+}
+function createEmptyPreview(args) {
+	return {
+		index: args.index,
+		title: args.title,
+		subtitle: "",
+		diffCount: 0,
+		additions: 0,
+		deletions: 0,
+		hunkCount: 0,
+		hasChanges: false,
+		fromIndex: args.fromIndex,
+		toIndex: args.toIndex,
+		comparisonSource: args.comparisonSource,
+		beforePath: "",
+		afterPath: "",
+		beforeText: "",
+		afterText: "",
+		nonTextualDetails: []
+	};
+}
+function buildDiffPreview(args) {
+	const stats = require_diff_stats.computeDiffStats(args.beforeText, args.afterText);
+	const title = args.previousEntry ? `${args.previousEntry.shortRevision} -> ${args.currentEntry.shortRevision}` : `Initial revision -> ${args.currentEntry.shortRevision}`;
+	const subtitle = args.currentEntry.isWorkingTree ? "Working tree" : `${formatEntryDateTime(args.currentEntry.authorDate)} · ${args.currentEntry.description}`;
+	return {
+		index: args.index,
+		title,
+		subtitle,
+		diffCount: 0,
+		additions: stats.additions,
+		deletions: stats.deletions,
+		hunkCount: stats.hunkCount,
+		hasChanges: stats.hasChanges,
+		fromIndex: args.fromIndex,
+		toIndex: args.toIndex,
+		comparisonSource: args.comparisonSource,
+		beforePath: args.beforePath,
+		afterPath: args.afterPath,
+		beforeText: args.beforeText,
+		afterText: args.afterText,
+		nonTextualDetails: stats.hasChanges ? [] : require_non_textual_details.buildNonTextualDetails({
+			beforeText: args.beforeText,
+			afterText: args.afterText,
+			beforePath: args.beforePath,
+			afterPath: args.afterPath,
+			isWorkingTree: args.currentEntry.isWorkingTree
+		})
+	};
+}
+function mergeTimelineEntries(args) {
+	const touchingByRevision = new Map(args.fileEntries.map((entry) => [entry.revision, entry]));
+	const repoIndexes = args.fileEntries.map((entry) => args.repositoryEntries.findIndex((candidate) => candidate.revision === entry.revision)).filter((index) => index >= 0);
+	if (!repoIndexes.length) return args.fileEntries;
+	const startIndex = Math.min(...repoIndexes);
+	const endIndex = Math.max(...repoIndexes);
+	const merged = args.repositoryEntries.slice(startIndex, endIndex + 1).map((entry) => touchingByRevision.get(entry.revision) || entry);
+	for (const entry of args.fileEntries) if (!merged.some((candidate) => candidate.revision === entry.revision)) merged.push(entry);
+	return merged.toSorted((left, right) => left.timestamp - right.timestamp || left.revision.localeCompare(right.revision));
+}
+function dedupeAdjacentTimelineEntries(entries) {
+	return entries.reduce((deduped, entry) => {
+		const previousEntry = deduped.at(-1);
+		if (!previousEntry?.changeId || previousEntry.changeId !== entry.changeId) {
+			deduped.push(entry);
+			return deduped;
+		}
+		if (previousEntry.touchesFile && entry.touchesFile) {
+			deduped.push(entry);
+			return deduped;
+		}
+		if (!previousEntry.touchesFile && entry.touchesFile) deduped[deduped.length - 1] = entry;
+		return deduped;
+	}, []);
+}
+function formatEntryMonthLabel(authorDate) {
+	const date = new Date(authorDate);
+	if (Number.isNaN(date.getTime())) return "Unknown month";
+	return new Intl.DateTimeFormat("en", { month: "long" }).format(date);
+}
+function formatEntryShortDate(authorDate) {
+	const date = new Date(authorDate);
+	if (Number.isNaN(date.getTime())) return "Unknown date";
+	return new Intl.DateTimeFormat("en", {
+		month: "short",
+		day: "numeric",
+		year: "numeric"
+	}).format(date);
+}
+function formatRelativeTime(timestamp) {
+	const deltaSeconds = Math.round((timestamp - Date.now()) / 1e3);
+	const formatter = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+	for (const [unit, amount] of [
+		["day", 86400],
+		["hour", 3600],
+		["minute", 60]
+	]) if (Math.abs(deltaSeconds) >= amount || unit === "minute") return formatter.format(Math.round(deltaSeconds / amount), unit);
+	return formatter.format(deltaSeconds, "second");
+}
+function formatEntryDateTime(authorDate) {
+	const date = new Date(authorDate);
+	if (Number.isNaN(date.getTime())) return "Unknown time";
+	return date.toLocaleString();
+}
+function isAbortError(error) {
+	return error instanceof Error && (error.name === "AbortError" || /aborted/i.test(error.message));
+}
+//#endregion
+exports.createTimelineService = createTimelineService;
+exports.normalizeTimelinePreferences = normalizeTimelinePreferences;
+
+//# sourceMappingURL=timeline-service.cjs.map