nano-git 0.3.0 → 0.3.2

package/README.md

@@ -347,6 +347,12 @@ console.log(obj.type); // => "blob"
 bun run examples/demo.ts
 ```
 
+运行 Virtual Workdir diff 基准：
+
+```bash
+bun run bench:workdir-diff
+```
+
 演示脚本展示了：
 
 - SHA-1 哈希计算

package/dist/workdir/change-index-plan.mjs

@@ -0,0 +1,76 @@
+import { resolvePath } from "./workdir-path.mjs";
+//#region src/workdir/change-index-plan.ts
+/**
+* Virtual Workdir change-index 刷新策略
+*
+* 把 workdir 写路径里的“是否允许增量刷新”判断与
+* “应该执行哪种 change-index 更新动作”集中到单独模块。
+*/
+/**
+* 创建 change-index 刷新策略器。
+*
+* @example
+* ```ts
+* const planner = createChangeIndexPlanner(source, state, {
+*   rebuildAll() {},
+*   refreshPath() {},
+*   rewriteRename() {},
+*   writeCopy() {},
+* });
+* expect(planner.planRefreshForPath("a.txt").kind).toBe("refresh-path");
+* ```
+*/
+function createChangeIndexPlanner(source, state, actions) {
+	const canIncrementallyRefreshPath = (path, options) => {
+		const record = state.getChangeRecord(path);
+		if (record !== null && record.source !== null) return false;
+		const resolved = resolvePath(source, state, path);
+		if (!resolved.found || resolved.node === null) return options?.treatMissingAsIncremental === true;
+		return resolved.node.state.kind !== "directory";
+	};
+	const canIncrementallyWriteCopy = (from) => {
+		const resolved = resolvePath(source, state, from);
+		if (!resolved.found || resolved.node === null) return false;
+		return resolved.node.state.kind !== "directory";
+	};
+	return {
+		apply(plan) {
+			switch (plan.kind) {
+				case "rebuild-all":
+					actions.rebuildAll();
+					return;
+				case "refresh-path":
+					actions.refreshPath(plan.path);
+					return;
+				case "rewrite-rename":
+					actions.rewriteRename(plan.from, plan.to);
+					return;
+				case "write-copy":
+					actions.writeCopy(plan.from, plan.to);
+					return;
+			}
+		},
+		planRefreshForPath(path, options) {
+			return canIncrementallyRefreshPath(path, options) ? {
+				kind: "refresh-path",
+				path
+			} : { kind: "rebuild-all" };
+		},
+		planRewriteForRename(from, to) {
+			return canIncrementallyRefreshPath(from) && canIncrementallyRefreshPath(to, { treatMissingAsIncremental: true }) ? {
+				kind: "rewrite-rename",
+				from,
+				to
+			} : { kind: "rebuild-all" };
+		},
+		planWriteForCopy(from, to) {
+			return canIncrementallyWriteCopy(from) && canIncrementallyRefreshPath(to, { treatMissingAsIncremental: true }) ? {
+				kind: "write-copy",
+				from,
+				to
+			} : { kind: "rebuild-all" };
+		}
+	};
+}
+//#endregion
+export { createChangeIndexPlanner };

package/dist/workdir/change-index.d.mts

@@ -0,0 +1,21 @@
+import { VirtualDiffObject, VirtualDiffSource } from "./core.mjs";
+
+//#region src/workdir/change-index.d.ts
+/**
+ * 规范化变更记录
+ *
+ * 仅保留相对 baseTree 的最终净效应；
+ * 若路径已恢复为 clean，则不保存记录。
+ */
+interface NormalizedChangeRecord {
+  /** 当前路径 */
+  readonly path: string;
+  /** 变更前对象 */
+  readonly previous: VirtualDiffObject | null;
+  /** 变更后对象 */
+  readonly current: VirtualDiffObject | null;
+  /** rename/copy 来源 */
+  readonly source: VirtualDiffSource | null;
+}
+//#endregion
+export { NormalizedChangeRecord };

package/dist/workdir/change-index.mjs

@@ -0,0 +1,413 @@
+import { hashObject } from "../core/hash-digest.mjs";
+import { readRepoBlobContent, readRepoTree } from "./origin.mjs";
+import { getDirectoryChildrenView, joinChildPath, resolveCurrentLeafAtPath } from "./workdir-path.mjs";
+import { observeListedDirectoryChild } from "./directory-view.mjs";
+//#region src/workdir/change-index.ts
+/**
+* Virtual Workdir 规范化变更索引
+*
+* 第一阶段先完成模型切换：
+* - 对外 `diff()` 改为读取规范化变更索引
+* - 写事务结束前重建净效应表并持久化
+*
+* 当前实现仍复用全量快照算法重建索引，
+* 后续阶段再替换为真正的增量维护。
+*/
+const baseSnapshotCache = /* @__PURE__ */ new WeakMap();
+/**
+* 重建当前 workdir 的规范化变更索引。
+*
+* @example
+* ```ts
+* const records = rebuildNormalizedChangeIndex(repo.objects, state);
+* expect(records.map((record) => record.path)).toEqual(["hello.txt"]);
+* ```
+*/
+function rebuildNormalizedChangeIndex(source, state, cache) {
+	const baseSnapshot = baseSnapshotViewForTree(source, state.readBaseTree());
+	const baseEntries = baseSnapshot.entries;
+	const currentEntries = snapshotCurrentTree(source, state, cache);
+	const baseByPath = baseSnapshot.byPath;
+	const currentByPath = new Map(currentEntries.map((entry) => [entry.path, entry]));
+	const deletes = /* @__PURE__ */ new Map();
+	const adds = /* @__PURE__ */ new Map();
+	const out = [];
+	const allPaths = /* @__PURE__ */ new Set([...baseByPath.keys(), ...currentByPath.keys()]);
+	for (const path of Array.from(allPaths).sort()) {
+		const previous = baseByPath.get(path) ?? null;
+		const current = currentByPath.get(path) ?? null;
+		if (previous !== null && current !== null) {
+			if (!isSameObject(previous.object, current.object)) out.push({
+				path,
+				previous: previous.object,
+				current: current.object,
+				source: null
+			});
+			continue;
+		}
+		if (previous !== null) {
+			deletes.set(path, {
+				path,
+				previous: previous.object,
+				current: null,
+				source: null
+			});
+			continue;
+		}
+		if (current !== null) adds.set(path, {
+			path,
+			previous: null,
+			current: current.object,
+			source: null
+		});
+	}
+	const unmatchedDeletesBySignature = indexDeletesBySignature(deletes);
+	const matchedDeletePaths = /* @__PURE__ */ new Set();
+	for (const [path, addRecord] of Array.from(adds.entries()).sort(([left], [right]) => left.localeCompare(right))) {
+		const current = currentByPath.get(path);
+		if (current === void 0 || current.originSignature === null) continue;
+		const renameFrom = (unmatchedDeletesBySignature.get(current.originSignature) ?? []).find((candidate) => !matchedDeletePaths.has(candidate.path));
+		if (renameFrom !== void 0) {
+			matchedDeletePaths.add(renameFrom.path);
+			adds.delete(path);
+			deletes.delete(renameFrom.path);
+			out.push({
+				path,
+				previous: renameFrom.previous,
+				current: addRecord.current,
+				source: {
+					kind: "rename",
+					path: renameFrom.path
+				}
+			});
+			continue;
+		}
+		const copyFrom = findCopySource(baseEntries, current);
+		if (copyFrom !== null) {
+			adds.delete(path);
+			out.push({
+				path,
+				previous: null,
+				current: addRecord.current,
+				source: {
+					kind: "copy",
+					path: copyFrom.path
+				}
+			});
+		}
+	}
+	out.push(...deletes.values(), ...adds.values());
+	return out.sort((left, right) => left.path.localeCompare(right.path));
+}
+/**
+* 将规范化变更索引导出为公开 diff 结果。
+*
+* @example
+* ```ts
+* const diff = exportVirtualDiffFromChangeRecords(records);
+* expect(diff).toHaveLength(1);
+* ```
+*/
+function exportVirtualDiffFromChangeRecords(records) {
+	return records.map((record) => {
+		if (record.previous === null && record.current !== null) return {
+			kind: "create",
+			path: record.path,
+			current: record.current,
+			source: record.source ?? void 0
+		};
+		if (record.previous !== null && record.current === null) return {
+			kind: "remove",
+			path: record.path,
+			previous: record.previous
+		};
+		if (record.previous !== null && record.current !== null) return {
+			kind: "update",
+			path: record.path,
+			previous: record.previous,
+			current: record.current,
+			changes: diffChanges(record.previous, record.current),
+			source: record.source ?? void 0
+		};
+		throw new Error(`Invalid normalized change record at path: ${record.path}`);
+	}).sort((left, right) => left.path.localeCompare(right.path));
+}
+/**
+* 将新索引完整写回状态存储。
+*/
+function replaceChangeRecords(state, records) {
+	const nextByPath = new Map(records.map((record) => [record.path, record]));
+	for (const existing of state.listChangeRecords()) if (!nextByPath.has(existing.path)) state.deleteChangeRecord(existing.path);
+	for (const record of records) state.setChangeRecord(record);
+}
+/**
+* 仅刷新单一路径的规范化变更记录。
+*
+* 适用于同路径叶子节点写入等高频场景，
+* 可避免在简单写操作后重建整张索引。
+*/
+function refreshChangeRecordForPath(source, state, path, cache) {
+	const nextRecord = computeChangeRecordForPath(source, state, path, state.getChangeRecord(path), cache);
+	if (nextRecord === null) {
+		state.deleteChangeRecord(path);
+		return;
+	}
+	state.setChangeRecord(nextRecord);
+}
+/**
+* 将单一路径的变更记录折叠为 rename 目标路径。
+*
+* 仅适用于叶子节点 rename；
+* 目录及无法判定来源的情况应由调用方回退到全量重建。
+*/
+function rewriteChangeRecordForRename(source, state, from, to, cache) {
+	const previousRecord = state.getChangeRecord(from);
+	const currentTarget = snapshotCurrentEntryAtPath(source, state, to, cache);
+	if (currentTarget === null) throw new Error(`Cannot rewrite rename change record for missing path: ${to}`);
+	const nextRecord = computeRenameRecordForPath(source, state, from, to, previousRecord, currentTarget);
+	if (nextRecord === null) throw new Error(`Cannot rewrite rename change record from '${from}' to '${to}'`);
+	state.deleteChangeRecord(from);
+	state.setChangeRecord(nextRecord);
+}
+/**
+* 为 copy 目标路径写入折叠后的变更记录。
+*
+* 仅适用于叶子节点 copy；
+* workdir-only 来源允许退化为普通 create。
+*/
+function writeChangeRecordForCopy(source, state, from, to, cache) {
+	const sourceRecord = state.getChangeRecord(from);
+	const currentTarget = snapshotCurrentEntryAtPath(source, state, to, cache);
+	if (currentTarget === null) throw new Error(`Cannot write copy change record for missing path: ${to}`);
+	state.setChangeRecord({
+		path: to,
+		previous: null,
+		current: currentTarget.object,
+		source: deriveCopySource(from, sourceRecord, source, state)
+	});
+}
+function snapshotBaseTree(source, treeHash, dirPath) {
+	if (dirPath === "") {
+		const cached = getCachedBaseSnapshot(source, treeHash);
+		if (cached !== null) return [...cached.entries];
+	}
+	const tree = readRepoTree(source, treeHash, dirPath);
+	const out = [];
+	for (const entry of tree.entries) {
+		const path = joinChildPath(dirPath, entry.name);
+		if (entry.mode === "40000") {
+			out.push(...snapshotBaseTree(source, entry.hash, path));
+			continue;
+		}
+		const object = createDiffObject(normalizeBlobMode(entry.mode), entry.hash);
+		out.push({
+			path,
+			object,
+			originSignature: buildOriginSignature(object.mode, object.hash)
+		});
+	}
+	if (dirPath === "") setCachedBaseSnapshot(source, treeHash, createBaseSnapshotView(out));
+	return out;
+}
+function baseSnapshotViewForTree(source, treeHash) {
+	const cached = getCachedBaseSnapshot(source, treeHash);
+	if (cached !== null) return cached;
+	const view = createBaseSnapshotView(snapshotBaseTree(source, treeHash, ""));
+	setCachedBaseSnapshot(source, treeHash, view);
+	return view;
+}
+function snapshotCurrentTree(source, state, cache) {
+	const root = state.getNode("root");
+	if (root === null) throw new Error("Virtual workdir is missing root node");
+	return snapshotCurrentNode(source, state, root, "", cache);
+}
+function snapshotCurrentNode(source, state, node, path, cache) {
+	if (node.state.kind === "directory") {
+		const out = [];
+		for (const child of getDirectoryChildrenView(source, state, node, path).children) {
+			const observedChild = observeListedDirectoryChild(state, path, child);
+			if (observedChild === null) continue;
+			out.push(...snapshotCurrentNode(source, state, observedChild.node, observedChild.path, cache));
+		}
+		return out;
+	}
+	return [snapshotCurrentLeafNode(source, {
+		path,
+		node
+	}, cache)];
+}
+function currentNodeHash(source, node, path, cache) {
+	if (node.state.kind === "file") {
+		if (node.state.content !== void 0) {
+			const cached = cache?.currentNodeHashes.get(node.id);
+			if (cached !== void 0) return cached;
+			const hash = hashObject("blob", node.state.content);
+			cache?.setCurrentNodeHash(node.id, hash);
+			return hash;
+		}
+		if (node.origin.kind === "repo-blob") return node.origin.hash;
+	}
+	if (node.state.kind === "symlink") {
+		if (node.state.target !== void 0) {
+			const cached = cache?.currentNodeHashes.get(node.id);
+			if (cached !== void 0) return cached;
+			const hash = hashObject("blob", node.state.target);
+			cache?.setCurrentNodeHash(node.id, hash);
+			return hash;
+		}
+		if (node.origin.kind === "repo-blob") return node.origin.hash;
+	}
+	if (node.origin.kind === "repo-blob") return hashObject("blob", readRepoBlobContent(source, node.origin.hash, path));
+	throw new Error(`Virtual workdir diff cannot resolve hash for path: ${path}`);
+}
+function computeChangeRecordForPath(source, state, path, previousRecord, cache) {
+	const baseEntry = baseSnapshotEntryAtPath(source, state.readBaseTree(), path);
+	const currentEntry = snapshotCurrentEntryAtPath(source, state, path, cache);
+	const preservedLineage = preserveLineageRecordForPath(path, previousRecord, currentEntry);
+	if (preservedLineage !== void 0) return preservedLineage;
+	if (baseEntry === null && currentEntry === null) return null;
+	if (baseEntry === null && currentEntry !== null) return createNormalizedChangeRecord(path, null, currentEntry.object);
+	if (baseEntry !== null && currentEntry === null) return createNormalizedChangeRecord(path, baseEntry.object, null);
+	if (baseEntry !== null && currentEntry !== null) {
+		if (isSameObject(baseEntry.object, currentEntry.object)) return null;
+		return createNormalizedChangeRecord(path, baseEntry.object, currentEntry.object);
+	}
+	throw new Error(`Unreachable change-record state at path: ${path}`);
+}
+function computeRenameRecordForPath(source, state, from, to, previousRecord, currentTarget) {
+	const derivedFromPrevious = deriveRenameRecordFromPreviousRecord(from, to, previousRecord, currentTarget);
+	if (derivedFromPrevious !== void 0) return derivedFromPrevious;
+	const baseEntry = baseSnapshotEntryAtPath(source, state.readBaseTree(), from);
+	if (baseEntry === null) return null;
+	return createNormalizedChangeRecord(to, baseEntry.object, currentTarget.object, createDiffSource("rename", from));
+}
+function deriveCopySource(from, sourceRecord, source, state) {
+	const fromRecordSource = sourceRecord?.source;
+	if (fromRecordSource !== null && fromRecordSource !== void 0) return createDiffSource("copy", fromRecordSource.path);
+	if (sourceRecord?.previous !== null || baseSnapshotEntryAtPath(source, state.readBaseTree(), from) !== null) return createDiffSource("copy", from);
+	return null;
+}
+function preserveLineageRecordForPath(path, previousRecord, currentEntry) {
+	if (previousRecord?.source?.kind === "rename" && previousRecord.previous !== null) {
+		if (currentEntry === null) return null;
+		return createNormalizedChangeRecord(path, previousRecord.previous, currentEntry.object, previousRecord.source);
+	}
+	if (previousRecord?.source?.kind === "copy") {
+		if (currentEntry === null) return null;
+		return createNormalizedChangeRecord(path, null, currentEntry.object, previousRecord.source);
+	}
+}
+function deriveRenameRecordFromPreviousRecord(from, to, previousRecord, currentTarget) {
+	if (previousRecord === null) return;
+	if (previousRecord.current === null) return null;
+	if (previousRecord.source !== null) return createNormalizedChangeRecord(to, previousRecord.previous, currentTarget.object, previousRecord.source);
+	if (previousRecord.previous === null) return createNormalizedChangeRecord(to, null, currentTarget.object);
+	return createNormalizedChangeRecord(to, previousRecord.previous, currentTarget.object, createDiffSource("rename", from));
+}
+function snapshotCurrentEntryAtPath(source, state, path, cache) {
+	const resolved = resolveCurrentLeafAtPath(source, state, path);
+	if (resolved === null) return null;
+	return snapshotCurrentLeafNode(source, resolved, cache);
+}
+function snapshotCurrentLeafNode(source, leaf, cache) {
+	if (leaf.node.state.kind === "directory") throw new Error(`snapshotCurrentLeafNode called on directory: ${leaf.path}`);
+	const hash = currentNodeHash(source, leaf.node, leaf.path, cache);
+	const object = createDiffObject(leaf.node.state.mode, hash);
+	return {
+		path: leaf.path,
+		object,
+		originSignature: leaf.node.origin.kind === "repo-blob" ? buildOriginSignature(leaf.node.origin.mode, leaf.node.origin.hash) : null
+	};
+}
+function createNormalizedChangeRecord(path, previous, current, source = null) {
+	return {
+		path,
+		previous,
+		current,
+		source
+	};
+}
+function createDiffSource(kind, path) {
+	return {
+		kind,
+		path
+	};
+}
+function createDiffObject(mode, hash) {
+	return {
+		kind: modeKind(mode),
+		mode,
+		hash
+	};
+}
+function diffChanges(previous, current) {
+	return {
+		kindChanged: previous.kind !== current.kind,
+		modeChanged: previous.mode !== current.mode,
+		contentChanged: previous.hash !== current.hash
+	};
+}
+function isSameObject(previous, current) {
+	return previous.kind === current.kind && previous.mode === current.mode && previous.hash === current.hash;
+}
+function normalizeBlobMode(mode) {
+	if (mode === "100755" || mode === "120000") return mode;
+	return "100644";
+}
+function buildOriginSignature(mode, hash) {
+	return `${mode}:${hash}`;
+}
+function getCachedBaseSnapshot(source, treeHash) {
+	return baseSnapshotCache.get(source)?.get(treeHash) ?? null;
+}
+function setCachedBaseSnapshot(source, treeHash, view) {
+	const cache = baseSnapshotCache.get(source) ?? /* @__PURE__ */ new Map();
+	cache.set(treeHash, view);
+	baseSnapshotCache.set(source, cache);
+}
+function createBaseSnapshotView(entries) {
+	return {
+		entries,
+		byPath: new Map(entries.map((entry) => [entry.path, entry]))
+	};
+}
+function baseSnapshotEntryAtPath(source, treeHash, path) {
+	return baseSnapshotViewForTree(source, treeHash).byPath.get(path) ?? null;
+}
+function indexDeletesBySignature(deletes) {
+	const out = /* @__PURE__ */ new Map();
+	for (const entry of deletes.values()) {
+		if (entry.previous === null) continue;
+		const signature = buildOriginSignature(entry.previous.mode, entry.previous.hash);
+		const list = out.get(signature) ?? [];
+		list.push(entry);
+		out.set(signature, list);
+	}
+	return out;
+}
+function findCopySource(baseEntries, current) {
+	if (current.originSignature === null) return null;
+	const source = baseEntries.filter((entry) => entry.originSignature === current.originSignature).sort((left, right) => left.path.localeCompare(right.path))[0];
+	if (source === void 0) return null;
+	return {
+		path: source.path,
+		entry: source
+	};
+}
+function modeKind(mode) {
+	return mode === "120000" ? "symlink" : "blob";
+}
+/**
+* 从规范化变更索引导出当前 workdir 的最终 diff。
+*
+* @example
+* ```ts
+* const diff = computeVirtualDiff(state);
+* expect(diff.map((entry) => entry.path)).toEqual(["hello.txt"]);
+* ```
+*/
+function computeVirtualDiff(state) {
+	return exportVirtualDiffFromChangeRecords(state.listChangeRecords());
+}
+//#endregion
+export { computeVirtualDiff, rebuildNormalizedChangeIndex, refreshChangeRecordForPath, replaceChangeRecords, rewriteChangeRecordForRename, writeChangeRecordForCopy };