nano-git 0.3.4 → 0.3.6

package/dist/workdir/write-tree.mjs

@@ -1,14 +1,19 @@
 import { writeObject } from "../objects/raw.mjs";
+import { originBackedNodeId } from "./ids.mjs";
 import { readRepoTree } from "./origin.mjs";
-import { listDirectoryChildren } from "./workdir-path.mjs";
-import { createNamedOriginChildLookup, observeListedDirectoryChild, observeNamedDirectoryChild, planAffectedDirectoryChildren } from "./directory-view.mjs";
-import { materializeDirtyDirSummary } from "./dirty-dir.mjs";
+import { joinChildPath } from "./workdir-path.mjs";
+import { createNamedOriginChildLookup, resolveNamedChild } from "./directory-view.mjs";
 //#region src/workdir/write-tree.ts
 /**
 * Virtual Workdir overlay -> tree 最小化编译
 *
-* 遍历 workdir 的目录 overlay，将受影响的目录重写为新 tree，
-* 未修改的 repo-backed 子树/文件尽量复用原对象哈希。
+* 采用 patchTree 式构造：从 change records + overlay 状态收集脏路径，
+* 沿受影响路径定向编译，只重写有变化的目录 tree 对象。
+*
+* 与旧实现的区别：
+* - 不依赖 DirtyDirSummary 预计算，writeFile/delete 等操作不再触发全量遍历
+* - 脏路径收集仅在 writeTree 时按需执行
+* - 已解析节点中的 overlay 修改通过定向遍历发现
 *
 * writeTree() 成功后不清空 overlay，不推进 baseTree。
 */
@@ -30,131 +35,166 @@ import { materializeDirtyDirSummary } from "./dirty-dir.mjs";
 function writeTreeFromSession(source, state) {
 	const root = state.getNode("root");
 	if (root === null || root.state.kind !== "directory") throw new Error("Virtual workdir: root node is missing or not a directory");
-	return compileDirectory(source, source, state, root);
+	const changes = /* @__PURE__ */ new Map();
+	for (const record of state.listChangeRecords()) changes.set(record.path, record);
+	return compileDirectory({
+		writeSource: source,
+		readSource: source,
+		state,
+		changes,
+		dirtyPaths: collectDirtyPaths(source, state, changes)
+	}, root, "");
 }
 /**
-* 递归编译目录 overlay -> 新 tree
+* 收集所有需要编译的目录路径。
 *
-* 返回新 tree 的 SHA-1（若目录无任何变化则直接复用 origin hash）。
+* 来源：
+* 1. Change records 中每条路径及其祖先
+* 2. 已解析节点中有 overlay 修改的目录及其祖先
 */
-function compileDirectory(writeSource, readSource, state, dirNode, dirPath = "") {
-	if (dirNode.state.kind !== "directory") throw new Error("compileDirectory called on non-directory node");
-	const summary = state.getDirtyDirSummary(dirPath);
-	if (summary !== null && summary.hashState === "materialized" && summary.currentTreeHash !== null) return summary.currentTreeHash;
-	if (summary === null && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
-	let anyChanged = false;
-	const newEntries = collectCompiledEntries(writeSource, readSource, state, dirNode, dirPath, summary, (changed) => {
-		if (changed) anyChanged = true;
-	});
-	if (summary !== null && (summary.dirtyEntryCount > 0 || summary.dirtyDescendantCount > 0)) anyChanged = true;
-	if (!anyChanged && dirNode.origin.kind === "repo-tree") {
-		state.setDirtyDirSummary(materializeDirtyDirSummary(summary, dirPath, dirNode.origin.hash));
-		return dirNode.origin.hash;
-	}
-	newEntries.sort((a, b) => a.name.localeCompare(b.name));
-	const treeHash = writeObject(writeSource, {
-		type: "tree",
-		entries: newEntries
-	});
-	state.setDirtyDirSummary(materializeDirtyDirSummary(summary, dirPath, treeHash));
-	return treeHash;
+function collectDirtyPaths(source, state, changes) {
+	const dirty = /* @__PURE__ */ new Set();
+	for (const path of changes.keys()) addPathAndAncestors(dirty, path);
+	const root = state.getNode("root");
+	if (root !== null && root.state.kind === "directory") walkResolvedOverlayNodes(source, state, root, "", dirty);
+	return dirty;
 }
-function collectCompiledEntries(writeSource, readSource, state, dirNode, dirPath, summary, markChanged) {
-	if (dirNode.state.kind !== "directory") throw new Error("collectCompiledEntries called on non-directory node");
-	if (dirNode.origin.kind !== "repo-tree" || summary === null) return listDirectoryChildren(readSource, state, dirNode, dirPath).flatMap((child) => {
-		const observedChild = observeListedDirectoryChild(state, dirPath, child);
-		if (observedChild === null) return [];
-		const entry = compileChildEntry(writeSource, readSource, state, observedChild);
-		if (entry === null) return [];
-		markChanged(entry.changed);
-		return [entry.entry];
-	});
-	const originLookup = createNamedOriginChildLookup(readRepoTree(readSource, dirNode.origin.hash, dirPath).entries);
-	const childPlan = planAffectedDirectoryChildren(originLookup, collectAffectedChildNames(summary));
-	const out = [];
-	for (const planEntry of childPlan) {
-		if (!planEntry.shouldCompile) {
-			if (planEntry.originEntry === null) throw new Error(`collectCompiledEntries: missing origin entry for '${planEntry.name}'`);
-			out.push(planEntry.originEntry);
-			continue;
+/** 将路径及其所有祖先加入集合 */
+function addPathAndAncestors(dirty, path) {
+	dirty.add(path);
+	while (true) {
+		const slashIndex = path.lastIndexOf("/");
+		if (slashIndex < 0) {
+			if (path !== "") dirty.add("");
+			return;
 		}
-		const compiled = compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, planEntry.name, originLookup);
-		if (compiled === null) continue;
-		markChanged(compiled.changed);
-		out.push(compiled.entry);
+		path = path.slice(0, slashIndex);
+		dirty.add(path);
 	}
-	return out;
 }
-function collectAffectedChildNames(summary) {
-	return new Set(summary.affectedNames);
+/**
+* 沿已解析节点遍历，将存在 overlay 修改的目录路径加入脏路径集。
+*
+* 仅遍历已在 state 中解析的节点（origin 子节点通过 ensureNodeFromTreeEntry
+* 懒注册时才会在 state 中存在），未解析的子树跳过。
+*/
+function walkResolvedOverlayNodes(source, state, node, dirPath, dirty) {
+	if (node.state.kind !== "directory") return;
+	if (isNodeOverlayDirty(node)) addPathAndAncestors(dirty, dirPath);
+	if (node.origin.kind === "repo-tree") {
+		const tree = readRepoTree(source, node.origin.hash, dirPath);
+		for (const entry of tree.entries) {
+			if (entry.mode !== "040000") continue;
+			const childId = originBackedNodeId(entry.hash);
+			const childNode = state.getNode(childId);
+			if (childNode === null) continue;
+			walkResolvedOverlayNodes(source, state, childNode, joinChildPath(dirPath, entry.name), dirty);
+		}
+	}
+	for (const [name, childId] of node.state.overlay.addedEntries) {
+		const childNode = state.getNode(childId);
+		if (childNode === null || childNode.state.kind !== "directory") continue;
+		walkResolvedOverlayNodes(source, state, childNode, joinChildPath(dirPath, name), dirty);
+	}
 }
-function compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, name, originLookup) {
-	if (dirNode.state.kind !== "directory") throw new Error("compileNamedChildEntry called on non-directory node");
-	const observedChild = observeNamedDirectoryChild(state, dirNode, dirPath, originLookup, name);
-	if (observedChild === null) return null;
-	return compileChildEntry(writeSource, readSource, state, observedChild);
+function isNodeOverlayDirty(node) {
+	if (node.state.kind !== "directory") return false;
+	return node.state.overlay.addedEntries.size > 0 || node.state.overlay.deletedNames.size > 0;
 }
-function compileChildEntry(writeSource, readSource, state, child) {
-	const node = child.node;
-	if (node.state.kind === "directory") {
-		const newHash = compileDirectory(writeSource, readSource, state, node, child.path);
-		const originHash = node.origin.kind === "repo-tree" ? node.origin.hash : null;
-		return {
-			entry: {
-				mode: "040000",
-				name: child.name,
-				hash: newHash
-			},
-			changed: newHash !== originHash
-		};
+/**
+* 递归编译目录 -> tree 对象
+*
+* 返回新 tree 的 SHA-1（无变化时直接复用 origin hash）。
+*/
+function compileDirectory(ctx, dirNode, dirPath) {
+	if (dirNode.state.kind !== "directory") throw new Error("compileDirectory called on non-directory node");
+	if (!ctx.dirtyPaths.has(dirPath) && !isNodeOverlayDirty(dirNode) && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
+	let originEntries = [];
+	if (dirNode.origin.kind === "repo-tree") originEntries = readRepoTree(ctx.readSource, dirNode.origin.hash, dirPath).entries;
+	const overlay = dirNode.state.overlay;
+	const treeEntries = [];
+	if (dirNode.origin.kind === "repo-tree") {
+		const lookup = createNamedOriginChildLookup(originEntries);
+		for (const originEntry of originEntries) {
+			if (overlay.deletedNames.has(originEntry.name)) continue;
+			if (overlay.addedEntries.has(originEntry.name)) continue;
+			const childPath = joinChildPath(dirPath, originEntry.name);
+			if (originEntry.mode === "040000") {
+				const resolved = resolveNamedChild(ctx.state, dirNode, lookup, originEntry.name);
+				if (resolved.found && resolved.node.state.kind === "directory") if (ctx.dirtyPaths.has(childPath) || isNodeOverlayDirty(resolved.node)) {
+					const hash = compileDirectory(ctx, resolved.node, childPath);
+					treeEntries.push({
+						mode: "040000",
+						name: originEntry.name,
+						hash
+					});
+				} else treeEntries.push(originEntry);
+				else if (resolved.found) {
+					const compiled = compileNodeToEntry(ctx, resolved.node, childPath, originEntry.name);
+					if (compiled !== null) treeEntries.push(compiled);
+				} else treeEntries.push(originEntry);
+			} else if (ctx.changes.has(childPath)) {
+				const resolved = resolveNamedChild(ctx.state, dirNode, lookup, originEntry.name);
+				if (resolved.found) {
+					const compiled = compileNodeToEntry(ctx, resolved.node, childPath, originEntry.name);
+					if (compiled !== null) treeEntries.push(compiled);
+				}
+			} else treeEntries.push(originEntry);
+		}
+	}
+	for (const [name, nodeId] of overlay.addedEntries) {
+		const childNode = ctx.state.getNode(nodeId);
+		if (childNode === null) continue;
+		const compiled = compileNodeToEntry(ctx, childNode, joinChildPath(dirPath, name), name);
+		if (compiled !== null) treeEntries.push(compiled);
 	}
+	treeEntries.sort((a, b) => a.name.localeCompare(b.name));
+	return writeObject(ctx.writeSource, {
+		type: "tree",
+		entries: treeEntries
+	});
+}
+function compileNodeToEntry(ctx, node, childPath, childName) {
+	if (node.state.kind === "directory") return {
+		mode: "040000",
+		name: childName,
+		hash: compileDirectory(ctx, node, childPath)
+	};
 	if (node.state.kind === "file") {
 		if (node.state.content !== void 0) {
-			const hash = writeObject(writeSource, {
+			const hash = writeObject(ctx.writeSource, {
 				type: "blob",
 				content: node.state.content
 			});
 			return {
-				entry: {
-					mode: node.state.mode,
-					name: child.name,
-					hash
-				},
-				changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+				mode: node.state.mode,
+				name: childName,
+				hash
 			};
 		}
 		if (node.origin.kind === "repo-blob") return {
-			entry: {
-				mode: node.state.mode,
-				name: child.name,
-				hash: node.origin.hash
-			},
-			changed: false
+			mode: node.state.mode,
+			name: childName,
+			hash: node.origin.hash
 		};
 		return null;
 	}
-	if (node.state.target !== void 0) {
-		const hash = writeObject(writeSource, {
-			type: "blob",
-			content: node.state.target
-		});
-		return {
-			entry: {
-				mode: "120000",
-				name: child.name,
-				hash
-			},
-			changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+	if (node.state.kind === "symlink") {
+		if (node.state.target !== void 0) return {
+			mode: "120000",
+			name: childName,
+			hash: writeObject(ctx.writeSource, {
+				type: "blob",
+				content: node.state.target
+			})
 		};
-	}
-	if (node.origin.kind === "repo-blob") return {
-		entry: {
+		if (node.origin.kind === "repo-blob") return {
 			mode: "120000",
-			name: child.name,
+			name: childName,
 			hash: node.origin.hash
-		},
-		changed: false
-	};
+		};
+		return null;
+	}
 	return null;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-git",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "files": [
     "dist"
   ],

package/dist/workdir/dirty-dir-plan.mjs

@@ -1,73 +0,0 @@
-import { getRootNode } from "./workdir-path.mjs";
-import { observeDirectoryChildren } from "./directory-view.mjs";
-import { createDirtyDirSummary } from "./dirty-dir.mjs";
-//#region src/workdir/dirty-dir-plan.ts
-/**
-* Virtual Workdir dirty-dir summary 重建策略
-*
-* 把 workdir 写路径里的脏目录摘要清理与重建逻辑集中到单独模块，
-* 让 workdir.ts 更接近纯编排层。
-*/
-/**
-* 创建 dirty-dir summary 策略器。
-*
-* @example
-* ```ts
-* const planner = createDirtyDirPlanner(source, state);
-* planner.rebuild(["src/index.ts"]);
-* ```
-*/
-function createDirtyDirPlanner(source, state) {
-	return {
-		clear() {
-			for (const summary of state.listDirtyDirSummaries()) state.deleteDirtyDirSummary(summary.path);
-		},
-		rebuild(touchedPaths) {
-			const nextSummaries = /* @__PURE__ */ new Map();
-			const invalidatedDirPaths = collectInvalidatedSummaryPaths(touchedPaths);
-			const visitDirectory = (node, dirPath) => {
-				if (node.state.kind !== "directory") throw new Error(`rebuildDirtyDirectorySummaries: '${dirPath}' is not a directory`);
-				const { affectedNames, dirtyDescendantCount } = observeDirectoryChildren(source, state, node, dirPath, {
-					onDirectoryChild(child) {
-						return visitDirectory(child.node, child.path);
-					},
-					isLeafChildDirty(child) {
-						return state.getChangeRecord(child.path) !== null;
-					}
-				});
-				if (affectedNames.size === 0 && dirtyDescendantCount === 0) return 0;
-				const existing = state.getDirtyDirSummary(dirPath);
-				const preserveHash = existing !== null && !invalidatedDirPaths.has(dirPath);
-				nextSummaries.set(dirPath, {
-					...createDirtyDirSummary(dirPath, Array.from(affectedNames)),
-					dirtyDescendantCount,
-					currentTreeHash: preserveHash ? existing.currentTreeHash : null,
-					hashState: preserveHash ? existing.hashState : "stale"
-				});
-				return affectedNames.size + dirtyDescendantCount;
-			};
-			visitDirectory(getRootNode(state), "");
-			for (const summary of state.listDirtyDirSummaries()) if (!nextSummaries.has(summary.path)) state.deleteDirtyDirSummary(summary.path);
-			for (const summary of nextSummaries.values()) state.setDirtyDirSummary(summary);
-		}
-	};
-}
-function collectInvalidatedSummaryPaths(paths) {
-	const out = /* @__PURE__ */ new Set();
-	for (const path of paths) {
-		out.add(path);
-		let cursor = path;
-		while (true) {
-			const slashIndex = cursor.lastIndexOf("/");
-			if (slashIndex < 0) {
-				out.add("");
-				break;
-			}
-			cursor = cursor.slice(0, slashIndex);
-			out.add(cursor);
-		}
-	}
-	return out;
-}
-//#endregion
-export { createDirtyDirPlanner };

package/dist/workdir/dirty-dir.mjs

@@ -1,32 +0,0 @@
-//#region src/workdir/dirty-dir.ts
-/**
-* 创建脏目录摘要记录
-*/
-function createDirtyDirSummary(path, affectedNames = []) {
-	const names = [...new Set(affectedNames)].sort((left, right) => left.localeCompare(right));
-	return {
-		path,
-		isDirty: true,
-		dirtyEntryCount: names.length,
-		dirtyDescendantCount: 0,
-		affectedNames: names,
-		currentTreeHash: null,
-		hashState: "stale"
-	};
-}
-/**
-* 将目录摘要标记为已物化 tree hash。
-*/
-function materializeDirtyDirSummary(current, path, treeHash) {
-	return {
-		path,
-		isDirty: true,
-		dirtyEntryCount: current?.dirtyEntryCount ?? 0,
-		dirtyDescendantCount: current?.dirtyDescendantCount ?? 0,
-		affectedNames: [...current?.affectedNames ?? []].sort((left, right) => left.localeCompare(right)),
-		currentTreeHash: treeHash,
-		hashState: "materialized"
-	};
-}
-//#endregion
-export { createDirtyDirSummary, materializeDirtyDirSummary };