jj-plus 0.10.10

package/dist/extension/history-adapters.cjs

@@ -0,0 +1,702 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+require("./constants.cjs");
+const require_history_helpers = require("../shared/history-helpers.cjs");
+const require_revset = require("../shared/revset.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+//#region src/extension/history-adapters.ts
+async function resolveHistoryAdapter(args) {
+	const { gitRoot, jjRoot } = await resolveRepositoryRoots(args);
+	if (require_history_helpers.resolvePreferredHistoryBackend({
+		workspacePath: args.workspacePath,
+		gitRoot,
+		jjRoot
+	}) === "jj") return createJjHistoryAdapter({ runner: args.runner });
+	return createGitHistoryAdapter({ runner: args.runner });
+}
+async function resolveHistoryWorkspacePath(args) {
+	const { gitRoot, jjRoot } = await resolveRepositoryRoots(args);
+	const preferredBackend = require_history_helpers.resolvePreferredHistoryBackend({
+		workspacePath: args.workspacePath,
+		gitRoot,
+		jjRoot
+	});
+	if (preferredBackend === "jj") return jjRoot || args.workspacePath;
+	if (preferredBackend === "git") return gitRoot || args.workspacePath;
+	return args.workspacePath;
+}
+async function resolveRepositoryRoots(args) {
+	const [gitResult, jjResult] = await Promise.allSettled([args.runner.runGit({
+		workspacePath: args.workspacePath,
+		args: ["rev-parse", "--show-toplevel"]
+	}), args.runner.runJj({
+		workspacePath: args.workspacePath,
+		args: ["root"]
+	})]);
+	return {
+		gitRoot: gitResult.status === "fulfilled" ? gitResult.value.stdout.trim() : void 0,
+		jjRoot: jjResult.status === "fulfilled" ? jjResult.value.stdout.trim() : void 0
+	};
+}
+function createGitHistoryAdapter(args) {
+	const { runner } = args;
+	return {
+		backend: "git",
+		async getFileRevisionHistory({ workspacePath, relativePath, limit, customRevset: _customRevset }) {
+			const { stdout } = await runner.runGit({
+				workspacePath,
+				args: [
+					"log",
+					"--follow",
+					"--decorate=short",
+					"--date=iso-strict",
+					"--format=%H%x09%ad%x09%an%x09%D%x09%s",
+					`--max-count=${limit ?? 200}`,
+					"--",
+					relativePath
+				]
+			});
+			return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map(parseGitHistoryLine).toReversed();
+		},
+		async getRepositoryRevisionHistory({ workspacePath, limit }) {
+			const { stdout } = await runner.runGit({
+				workspacePath,
+				args: [
+					"log",
+					"--decorate=short",
+					"--date=iso-strict",
+					"--format=%H%x09%ad%x09%an%x09%D%x09%s",
+					`--max-count=${limit ?? 200}`
+				]
+			});
+			return stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map(parseGitHistoryLine).map((entry) => ({
+				...entry,
+				touchesFile: false
+			})).toReversed();
+		},
+		async getRevisionDiff({ workspacePath, revision }) {
+			const { stdout } = await runner.runGit({
+				workspacePath,
+				args: [
+					"show",
+					"--format=",
+					"--find-renames",
+					revision
+				]
+			});
+			return stdout;
+		},
+		async showFileAtRevision({ workspacePath, revset, filePath }) {
+			if (revset === "EMPTY") return "";
+			try {
+				const { stdout } = await runner.runGit({
+					workspacePath,
+					args: ["show", `${revset}:${filePath}`]
+				});
+				return stdout;
+			} catch (error) {
+				if (isMissingFileAtRevisionError(error)) return "";
+				throw error;
+			}
+		},
+		async resolvePreviousPath({ workspacePath, revision, currentPath }) {
+			return (await resolvePreviousGitPath({
+				runner,
+				workspacePath,
+				revision,
+				currentPath
+			}))?.fromPath || currentPath;
+		},
+		async listRevisionFiles({ workspacePath, revision, signal }) {
+			const { stdout } = await runner.runGit({
+				workspacePath,
+				args: [
+					"diff-tree",
+					"--root",
+					"--no-commit-id",
+					"--name-only",
+					"-r",
+					revision
+				],
+				options: { signal }
+			});
+			return parseOutputLines(stdout);
+		},
+		async listRevisionTreeFiles({ workspacePath, revision, signal }) {
+			const { stdout } = await runner.runGit({
+				workspacePath,
+				args: [
+					"ls-tree",
+					"-r",
+					"--name-only",
+					revision
+				],
+				options: { signal }
+			});
+			return parseOutputLines(stdout).toSorted((left, right) => left.localeCompare(right));
+		},
+		async listWorkingTreeFiles({ workspacePath, signal }) {
+			const files = /* @__PURE__ */ new Set();
+			try {
+				const { stdout } = await runner.runGit({
+					workspacePath,
+					args: [
+						"diff",
+						"--name-only",
+						"HEAD",
+						"--"
+					],
+					options: { signal }
+				});
+				for (const relativePath of parseOutputLines(stdout)) files.add(relativePath);
+			} catch {}
+			return [...files].toSorted((left, right) => left.localeCompare(right));
+		},
+		async getRemoteBaseUrl({ workspacePath }) {
+			try {
+				const { stdout } = await runner.runGit({
+					workspacePath,
+					args: [
+						"remote",
+						"get-url",
+						"origin"
+					]
+				});
+				return require_history_helpers.getGitHubRemoteBaseUrl(stdout);
+			} catch {
+				return;
+			}
+		},
+		async getSnapshotEntriesForFile() {
+			return [];
+		},
+		async buildRangeMultiDiffPlan({ workspacePath, fromEntry, toEntry, signal }) {
+			const changedFiles = toEntry.isWorkingTree ? await listGitChangedFiles({
+				runner,
+				workspacePath,
+				fromRevision: fromEntry.revision,
+				signal
+			}) : await listGitChangedFiles({
+				runner,
+				workspacePath,
+				fromRevision: fromEntry.revision,
+				toRevision: toEntry.revision,
+				signal
+			});
+			return {
+				title: `${fromEntry.shortRevision}..${toEntry.shortRevision}`,
+				files: changedFiles.map((relativePath) => ({
+					relativePath,
+					originalRevset: fromEntry.revision,
+					modifiedRevset: toEntry.isWorkingTree ? "@" : toEntry.revision,
+					backend: "git"
+				}))
+			};
+		},
+		async buildRevisionMultiDiffPlan({ workspacePath, entry, signal }) {
+			const files = parseOutputLines((await runner.runGit({
+				workspacePath,
+				args: [
+					"diff-tree",
+					"--root",
+					"--no-commit-id",
+					"--name-only",
+					"-r",
+					entry.revision
+				],
+				options: { signal }
+			})).stdout);
+			const parentRevision = await resolveGitParentRevision({
+				runner,
+				workspacePath,
+				revision: entry.revision,
+				signal
+			});
+			return {
+				title: entry.shortRevision,
+				files: files.map((relativePath) => ({
+					relativePath,
+					originalRevset: parentRevision || "EMPTY",
+					modifiedRevset: entry.revision,
+					backend: "git"
+				}))
+			};
+		}
+	};
+}
+function createJjHistoryAdapter(args) {
+	const { runner } = args;
+	return {
+		backend: "jj",
+		async getFileRevisionHistory({ workspacePath, relativePath, limit, customRevset }) {
+			return collectJjFileRevisionHistory({
+				runner,
+				workspacePath,
+				relativePath,
+				limit: limit ?? 200,
+				customRevset
+			});
+		},
+		async getRepositoryRevisionHistory({ workspacePath, limit, customRevset }) {
+			const template = require_history_helpers.buildJjHistoryLogTemplate();
+			const { stdout } = await runner.runJj({
+				workspacePath,
+				args: [
+					"log",
+					"--no-graph",
+					"--limit",
+					String(limit ?? 200),
+					"-r",
+					customRevset?.trim() || "ancestors(@)",
+					"-T",
+					template
+				]
+			});
+			return require_history_helpers.dedupeAdjacentEntriesByChangeId(stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map(require_history_helpers.parseJjHistoryLine).map((entry) => ({
+				...entry,
+				touchesFile: false
+			})).toReversed());
+		},
+		async getRevisionDiff({ workspacePath, revision }) {
+			const { stdout } = await runner.runJj({
+				workspacePath,
+				args: [
+					"diff",
+					"--git",
+					"-r",
+					revision
+				]
+			});
+			return stdout;
+		},
+		async showFileAtRevision({ workspacePath, revset, filePath }) {
+			if (revset === "EMPTY") return "";
+			try {
+				const { stdout } = await runner.runJj({
+					workspacePath,
+					args: [
+						"file",
+						"show",
+						"-r",
+						revset,
+						require_history_helpers.toJjRootFileFileset(filePath)
+					]
+				});
+				return stdout;
+			} catch (error) {
+				if (isMissingFileAtRevisionError(error)) return "";
+				throw error;
+			}
+		},
+		async resolvePreviousPath({ workspacePath, revision, currentPath }) {
+			try {
+				const { stdout } = await runner.runJj({
+					workspacePath,
+					args: [
+						"diff",
+						"--summary",
+						"-r",
+						revision
+					]
+				});
+				const rename = require_history_helpers.parseJjSummaryRenameLines(stdout).find((entry) => entry.toPath === currentPath);
+				if (rename) return rename.fromPath;
+			} catch {}
+			const previousTransition = await resolvePreviousGitPath({
+				runner,
+				workspacePath,
+				revision,
+				currentPath
+			});
+			return shouldFollowPredecessorTransition(previousTransition) ? previousTransition.fromPath : currentPath;
+		},
+		async listRevisionFiles({ workspacePath, revision, signal }) {
+			const { stdout } = await runner.runJj({
+				workspacePath,
+				args: [
+					"diff",
+					"--name-only",
+					"-r",
+					revision
+				],
+				options: { signal }
+			});
+			return parseOutputLines(stdout);
+		},
+		async listRevisionTreeFiles({ workspacePath, revision, signal }) {
+			const { stdout } = await runner.runJj({
+				workspacePath,
+				args: [
+					"file",
+					"list",
+					"-r",
+					revision
+				],
+				options: { signal }
+			});
+			return parseOutputLines(stdout).toSorted((left, right) => left.localeCompare(right));
+		},
+		async listWorkingTreeFiles({ workspacePath, signal }) {
+			const { stdout } = await runner.runJj({
+				workspacePath,
+				args: [
+					"diff",
+					"--name-only",
+					"-r",
+					"@"
+				],
+				options: { signal }
+			});
+			return parseOutputLines(stdout);
+		},
+		async getRemoteBaseUrl({ workspacePath }) {
+			try {
+				const { stdout } = await runner.runGit({
+					workspacePath,
+					args: [
+						"remote",
+						"get-url",
+						"origin"
+					]
+				});
+				return require_history_helpers.getGitHubRemoteBaseUrl(stdout);
+			} catch {
+				return;
+			}
+		},
+		async getSnapshotEntriesForFile({ workspacePath, relativePath, entry }) {
+			if (!entry.changeId || entry.isWorkingTree || !entry.touchesFile) return [];
+			try {
+				const { stdout } = await runner.runJj({
+					workspacePath,
+					args: [
+						"evolog",
+						"--no-graph",
+						"--summary",
+						"--limit",
+						String(200),
+						"-r",
+						entry.revision
+					]
+				});
+				return require_history_helpers.parseJjEvolutionSummaryEntries(stdout).filter((evolutionEntry) => require_history_helpers.parseJjSummaryChangedPaths(evolutionEntry.summaryLines).includes(relativePath)).map((evolutionEntry, evolutionIndex) => ({
+					id: `snapshot:${entry.changeId}:${evolutionEntry.operationId || evolutionEntry.changeKey || evolutionEntry.revision}:${evolutionIndex}`,
+					revision: evolutionEntry.revision,
+					shortRevision: require_history_helpers.normalizeSnapshotOperationKey(evolutionEntry.changeKey) || evolutionEntry.revision.slice(0, 8),
+					changeId: entry.changeId,
+					bookmarkNames: evolutionEntry.bookmarkNames,
+					authorDate: normalizeSnapshotAuthorDate(evolutionEntry.authorDate, entry.authorDate),
+					authorName: evolutionEntry.authorName || entry.authorName,
+					description: normalizeSnapshotDescription(evolutionEntry.description, evolutionEntry.operationDescription),
+					isWorkingTree: false,
+					touchesFile: true,
+					timestamp: parseSnapshotTimestamp(evolutionEntry.authorDate, entry.timestamp),
+					filePath: relativePath,
+					operationId: evolutionEntry.operationId,
+					operationIndex: evolutionEntry.operationIndex,
+					operationKey: evolutionEntry.changeKey
+				})).toReversed();
+			} catch {
+				return [];
+			}
+		},
+		async buildRangeMultiDiffPlan({ workspacePath, fromEntry, toEntry, signal }) {
+			let changedFiles = await listChangedJjFiles({
+				runner,
+				workspacePath,
+				base: fromEntry.revision,
+				target: toEntry.isWorkingTree ? "@" : toEntry.revision,
+				signal
+			});
+			let originalRevset = fromEntry.revision;
+			let modifiedRevset = toEntry.isWorkingTree ? "@" : toEntry.revision;
+			let title = `${fromEntry.shortRevision}..${toEntry.shortRevision}`;
+			if (!changedFiles.length && toEntry.isWorkingTree && fromEntry.revision !== modifiedRevset) {
+				const revisionFiles = await parseRevisionFilesForJj({
+					runner,
+					workspacePath,
+					revision: fromEntry.revision,
+					signal
+				});
+				if (revisionFiles.length) {
+					changedFiles = revisionFiles;
+					originalRevset = `${fromEntry.revision}-`;
+					modifiedRevset = fromEntry.revision;
+					title = fromEntry.shortRevision;
+				}
+			}
+			return {
+				title,
+				files: changedFiles.map((relativePath) => ({
+					relativePath,
+					originalRevset,
+					modifiedRevset,
+					backend: "jj"
+				}))
+			};
+		},
+		async buildRevisionMultiDiffPlan({ workspacePath, entry, entryIndex, comparisonSource, sourceEntries, signal }) {
+			const baseRevision = comparisonSource === "snapshot" ? sourceEntries[Math.max(0, entryIndex - 1)]?.revision || `${entry.revision}-` : `${entry.revision}-`;
+			const revisionFiles = comparisonSource === "snapshot" ? await listChangedJjFiles({
+				runner,
+				workspacePath,
+				base: baseRevision,
+				target: entry.revision,
+				signal
+			}) : await parseRevisionFilesForJj({
+				runner,
+				workspacePath,
+				revision: entry.revision,
+				signal
+			});
+			return {
+				title: entry.shortRevision,
+				files: revisionFiles.map((relativePath) => ({
+					relativePath,
+					originalRevset: baseRevision,
+					modifiedRevset: entry.revision,
+					backend: "jj"
+				}))
+			};
+		}
+	};
+}
+function parseGitHistoryLine(line) {
+	const [revision = "", authorDate = "", authorName = "", decorations = "", ...descriptionParts] = line.split("	");
+	return {
+		id: revision,
+		revision,
+		shortRevision: revision.slice(0, 8),
+		branchNames: require_history_helpers.parseGitBranchNames(decorations),
+		changeId: void 0,
+		authorDate,
+		authorName: authorName || "Unknown author",
+		description: descriptionParts.join("	") || "No description",
+		isWorkingTree: false,
+		touchesFile: true,
+		timestamp: Date.parse(authorDate) || 0
+	};
+}
+async function collectJjFileRevisionHistory(args) {
+	const ancestorLimitRevset = args.ancestorLimitRevset || "@";
+	const seenSegments = args.seenSegments || /* @__PURE__ */ new Set();
+	const segmentKey = `${args.relativePath}\u0000${ancestorLimitRevset}\u0000${args.customRevset || ""}`;
+	if (seenSegments.has(segmentKey)) return [];
+	seenSegments.add(segmentKey);
+	const segment = await loadJjFileHistorySegment(args.runner, args.workspacePath, args.relativePath, ancestorLimitRevset, args.limit, args.customRevset);
+	const previousSource = await resolvePreviousJjPath({
+		runner: args.runner,
+		workspacePath: args.workspacePath,
+		relativePath: args.relativePath,
+		segment
+	});
+	return mergeJjHistoryEntries(previousSource ? await collectJjFileRevisionHistory({
+		runner: args.runner,
+		workspacePath: args.workspacePath,
+		relativePath: previousSource.relativePath,
+		ancestorLimitRevset: previousSource.ancestorLimitRevset,
+		customRevset: args.customRevset,
+		seenSegments,
+		limit: args.limit
+	}) : [], segment.map(({ entry }) => entry));
+}
+async function loadJjFileHistorySegment(runner, workspacePath, relativePath, ancestorLimitRevset, limit, customRevset) {
+	const template = require_history_helpers.buildJjHistoryLogTemplate();
+	const { stdout } = await runner.runJj({
+		workspacePath,
+		args: [
+			"log",
+			"--no-graph",
+			"--reversed",
+			"--summary",
+			"--limit",
+			String(limit),
+			"-r",
+			require_revset.composeJjHistoryRevset({
+				defaultRevset: buildJjAncestorHistoryRevset(ancestorLimitRevset),
+				customRevset
+			}),
+			"-T",
+			template,
+			require_history_helpers.toJjRootFileFileset(relativePath)
+		]
+	});
+	return parseJjHistoryEntriesWithSummary(stdout);
+}
+function parseJjHistoryEntriesWithSummary(output) {
+	const entries = [];
+	let currentEntry = null;
+	for (const rawLine of output.split(/\r?\n/u)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		if (line.includes("	")) {
+			if (currentEntry) entries.push(currentEntry);
+			currentEntry = {
+				entry: require_history_helpers.parseJjHistoryLine(line),
+				summaryLines: []
+			};
+			continue;
+		}
+		if (currentEntry) currentEntry.summaryLines.push(line);
+	}
+	if (currentEntry) entries.push(currentEntry);
+	return entries;
+}
+function buildJjAncestorHistoryRevset(ancestorLimitRevset) {
+	return `ancestors(${ancestorLimitRevset})`;
+}
+async function resolvePreviousJjPath(args) {
+	const boundaryEntry = args.segment[0];
+	if (!boundaryEntry) return;
+	const boundarySummary = boundaryEntry.summaryLines.join("\n");
+	const rename = require_history_helpers.parseJjSummaryRenameLines(boundarySummary).find((entry) => entry.toPath === args.relativePath);
+	if (rename) return {
+		relativePath: rename.fromPath,
+		ancestorLimitRevset: `${boundaryEntry.entry.revision}-`
+	};
+	const previousTransition = await resolvePreviousGitPath({
+		runner: args.runner,
+		workspacePath: args.workspacePath,
+		revision: boundaryEntry.entry.revision,
+		currentPath: args.relativePath
+	});
+	if (!shouldFollowPredecessorTransition(previousTransition)) return;
+	return {
+		relativePath: previousTransition.fromPath,
+		ancestorLimitRevset: `${boundaryEntry.entry.revision}-`
+	};
+}
+function mergeJjHistoryEntries(...segments) {
+	const seenRevisions = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const segment of segments) for (const entry of segment) {
+		if (seenRevisions.has(entry.revision)) continue;
+		seenRevisions.add(entry.revision);
+		merged.push(entry);
+	}
+	return merged;
+}
+function parseOutputLines(output) {
+	return output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+function parseGitPathTransitionLines(output) {
+	return parseOutputLines(output).map((line) => {
+		const [status = "", fromPath = "", toPath = ""] = line.split("	");
+		if (!status.startsWith("R") && !status.startsWith("C")) return null;
+		return fromPath && toPath ? {
+			fromPath,
+			toPath,
+			kind: status.startsWith("C") ? "copy" : "rename"
+		} : null;
+	}).filter((entry) => entry !== null);
+}
+function shouldFollowPredecessorTransition(transition) {
+	if (!transition) return false;
+	if (transition.kind === "rename") return true;
+	return node_path.default.basename(transition.fromPath) === node_path.default.basename(transition.toPath);
+}
+async function resolvePreviousGitPath(args) {
+	try {
+		const { stdout } = await args.runner.runGit({
+			workspacePath: args.workspacePath,
+			args: [
+				"diff-tree",
+				"--root",
+				"--no-commit-id",
+				"--name-status",
+				"--find-renames=1%",
+				"--find-copies=1%",
+				"--find-copies-harder",
+				"-r",
+				args.revision
+			],
+			options: { signal: args.signal }
+		});
+		return parseGitPathTransitionLines(stdout).find((entry) => entry.toPath === args.currentPath);
+	} catch {
+		return;
+	}
+}
+function isMissingFileAtRevisionError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return /exists on disk, but not in/i.test(message) || /path .* does not exist in/i.test(message) || /no such path/i.test(message) || /no matching entries/i.test(message) || /No such file or directory/i.test(message);
+}
+function normalizeSnapshotAuthorDate(authorDate, fallbackAuthorDate) {
+	const value = authorDate.trim();
+	if (value && !Number.isNaN(Date.parse(value))) return value;
+	return fallbackAuthorDate;
+}
+function parseSnapshotTimestamp(authorDate, fallbackTimestamp) {
+	const timestamp = Date.parse(authorDate);
+	return Number.isNaN(timestamp) ? fallbackTimestamp : timestamp;
+}
+function normalizeSnapshotDescription(description, operationDescription) {
+	const trimmed = String(description || "").trim();
+	if (!trimmed || trimmed === "(no description set)" || trimmed === "(empty) (no description set)") return operationDescription || "Snapshot";
+	return trimmed;
+}
+async function listGitChangedFiles(args) {
+	const commandArgs = args.toRevision ? [
+		"diff",
+		"--name-only",
+		args.fromRevision,
+		args.toRevision,
+		"--"
+	] : [
+		"diff",
+		"--name-only",
+		args.fromRevision,
+		"--"
+	];
+	const { stdout } = await args.runner.runGit({
+		workspacePath: args.workspacePath,
+		args: commandArgs,
+		options: { signal: args.signal }
+	});
+	return parseOutputLines(stdout);
+}
+async function resolveGitParentRevision(args) {
+	try {
+		const { stdout } = await args.runner.runGit({
+			workspacePath: args.workspacePath,
+			args: ["rev-parse", `${args.revision}^`],
+			options: { signal: args.signal }
+		});
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+async function listChangedJjFiles(args) {
+	const { stdout } = await args.runner.runJj({
+		workspacePath: args.workspacePath,
+		args: [
+			"diff",
+			"--name-only",
+			"--from",
+			args.base,
+			"--to",
+			args.target
+		],
+		options: { signal: args.signal }
+	});
+	return parseOutputLines(stdout);
+}
+async function parseRevisionFilesForJj(args) {
+	const { stdout } = await args.runner.runJj({
+		workspacePath: args.workspacePath,
+		args: [
+			"diff",
+			"--name-only",
+			"-r",
+			args.revision
+		],
+		options: { signal: args.signal }
+	});
+	return parseOutputLines(stdout);
+}
+//#endregion
+exports.resolveHistoryAdapter = resolveHistoryAdapter;
+exports.resolveHistoryWorkspacePath = resolveHistoryWorkspacePath;
+
+//# sourceMappingURL=history-adapters.cjs.map