nano-git 0.2.3 → 0.3.1

package/dist/workdir/sqlite-backend.mjs

@@ -7,8 +7,7 @@ import { Database } from "bun:sqlite";
 /**
 * Virtual Workdir SQLite backend
 */
-const WORKDIR_SQLITE_SCHEMA_VERSION = 1;
-const WORKDIR_CHANGES_SESSION_ORDER_INDEX = "workdir_changes_session_id_id_idx";
+const WORKDIR_SQLITE_SCHEMA_VERSION = 5;
 /**
 * 创建基于 SQLite 的 Virtual Workdir backend
 *
@@ -95,14 +94,55 @@ function createSqliteVirtualWorkdirStateStore(db, sessionId) {
         target = excluded.target,
         directory_overlay = excluded.directory_overlay`);
 	const deleteNodeStmt = db.query("DELETE FROM workdir_nodes WHERE session_id = ? AND node_id = ?");
-	const listChangesStmt = db.query("SELECT op, path, old_path FROM workdir_changes WHERE session_id = ? ORDER BY id");
-	const insertChangeStmt = db.query("INSERT INTO workdir_changes (session_id, op, path, old_path) VALUES (?, ?, ?, ?)");
 	const clearNodesStmt = db.query("DELETE FROM workdir_nodes WHERE session_id = ?");
+	const listChangesStmt = db.query(`SELECT path, previous_kind, previous_mode, previous_hash, current_kind, current_mode, current_hash, source_kind, source_path
+     FROM workdir_changes
+     WHERE session_id = ?
+     ORDER BY path`);
+	const getChangeStmt = db.query(`SELECT path, previous_kind, previous_mode, previous_hash, current_kind, current_mode, current_hash, source_kind, source_path
+     FROM workdir_changes
+     WHERE session_id = ? AND path = ?`);
+	const upsertChangeStmt = db.query(`INSERT INTO workdir_changes (
+      session_id, path, previous_kind, previous_mode, previous_hash,
+      current_kind, current_mode, current_hash, source_kind, source_path
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(session_id, path) DO UPDATE SET
+      previous_kind = excluded.previous_kind,
+      previous_mode = excluded.previous_mode,
+      previous_hash = excluded.previous_hash,
+      current_kind = excluded.current_kind,
+      current_mode = excluded.current_mode,
+      current_hash = excluded.current_hash,
+      source_kind = excluded.source_kind,
+      source_path = excluded.source_path`);
+	const deleteChangeStmt = db.query("DELETE FROM workdir_changes WHERE session_id = ? AND path = ?");
 	const clearChangesStmt = db.query("DELETE FROM workdir_changes WHERE session_id = ?");
+	const listDirtyDirsStmt = db.query(`SELECT path, is_dirty, dirty_entry_count, dirty_descendant_count, affected_names, current_tree_hash, hash_state
+     FROM workdir_dirty_dirs
+     WHERE session_id = ?
+     ORDER BY path`);
+	const getDirtyDirStmt = db.query(`SELECT path, is_dirty, dirty_entry_count, dirty_descendant_count, affected_names, current_tree_hash, hash_state
+     FROM workdir_dirty_dirs
+     WHERE session_id = ? AND path = ?`);
+	const upsertDirtyDirStmt = db.query(`INSERT INTO workdir_dirty_dirs (
+      session_id, path, is_dirty, dirty_entry_count, dirty_descendant_count,
+      affected_names, current_tree_hash, hash_state
+    )
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(session_id, path) DO UPDATE SET
+       is_dirty = excluded.is_dirty,
+       dirty_entry_count = excluded.dirty_entry_count,
+       dirty_descendant_count = excluded.dirty_descendant_count,
+       affected_names = excluded.affected_names,
+       current_tree_hash = excluded.current_tree_hash,
+       hash_state = excluded.hash_state`);
+	const deleteDirtyDirStmt = db.query("DELETE FROM workdir_dirty_dirs WHERE session_id = ? AND path = ?");
+	const clearDirtyDirsStmt = db.query("DELETE FROM workdir_dirty_dirs WHERE session_id = ?");
 	const resetTx = db.transaction((baseTree) => {
 		upsertSessionStmt.run(sessionId, baseTree);
 		clearNodesStmt.run(sessionId);
 		clearChangesStmt.run(sessionId);
+		clearDirtyDirsStmt.run(sessionId);
 		writeNode(setNodeStmt, sessionId, createRootDirectoryNode(baseTree));
 	});
 	return {
@@ -129,14 +169,31 @@ function createSqliteVirtualWorkdirStateStore(db, sessionId) {
 		deleteNode(id) {
 			deleteNodeStmt.run(sessionId, id);
 		},
-		appendChange(record) {
-			insertChangeStmt.run(sessionId, record.op, getRecordPath(record), getRecordOldPath(record));
-		},
 		listChangeRecords() {
 			return listChangesStmt.all(sessionId).map(readChangeRecord);
 		},
-		clearChanges() {
-			clearChangesStmt.run(sessionId);
+		getChangeRecord(path) {
+			const row = getChangeStmt.get(sessionId, path);
+			return row === null ? null : readChangeRecord(row);
+		},
+		setChangeRecord(record) {
+			upsertChangeStmt.run(sessionId, record.path, record.previous?.kind ?? null, record.previous?.mode ?? null, record.previous?.hash ?? null, record.current?.kind ?? null, record.current?.mode ?? null, record.current?.hash ?? null, record.source?.kind ?? null, record.source?.path ?? null);
+		},
+		deleteChangeRecord(path) {
+			deleteChangeStmt.run(sessionId, path);
+		},
+		listDirtyDirSummaries() {
+			return listDirtyDirsStmt.all(sessionId).map(readDirtyDirSummary);
+		},
+		getDirtyDirSummary(path) {
+			const row = getDirtyDirStmt.get(sessionId, path);
+			return row === null ? null : readDirtyDirSummary(row);
+		},
+		setDirtyDirSummary(summary) {
+			upsertDirtyDirStmt.run(sessionId, summary.path, summary.isDirty ? 1 : 0, summary.dirtyEntryCount, summary.dirtyDescendantCount, JSON.stringify(summary.affectedNames), summary.currentTreeHash, summary.hashState);
+		},
+		deleteDirtyDirSummary(path) {
+			deleteDirtyDirStmt.run(sessionId, path);
 		},
 		reset(baseTree) {
 			resetTx(baseTree);
@@ -169,16 +226,31 @@ function ensureSchema(db) {
   `);
 	db.run(`
     CREATE TABLE IF NOT EXISTS workdir_changes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
-      op TEXT NOT NULL,
-      path TEXT,
-      old_path TEXT
+      path TEXT NOT NULL,
+      previous_kind TEXT,
+      previous_mode TEXT,
+      previous_hash TEXT,
+      current_kind TEXT,
+      current_mode TEXT,
+      current_hash TEXT,
+      source_kind TEXT,
+      source_path TEXT,
+      PRIMARY KEY (session_id, path)
     )
   `);
 	db.run(`
-    CREATE INDEX IF NOT EXISTS ${WORKDIR_CHANGES_SESSION_ORDER_INDEX}
-    ON workdir_changes (session_id, id)
+    CREATE TABLE IF NOT EXISTS workdir_dirty_dirs (
+      session_id TEXT NOT NULL,
+      path TEXT NOT NULL,
+      is_dirty INTEGER NOT NULL,
+      dirty_entry_count INTEGER NOT NULL,
+      dirty_descendant_count INTEGER NOT NULL,
+      affected_names TEXT NOT NULL,
+      current_tree_hash TEXT,
+      hash_state TEXT NOT NULL,
+      PRIMARY KEY (session_id, path)
+    )
   `);
 	writeSchemaVersion(db, WORKDIR_SQLITE_SCHEMA_VERSION);
 }
@@ -187,6 +259,7 @@ function hasSession(db, sessionId) {
 }
 function deleteSessionRows(db, sessionId) {
 	db.transaction(() => {
+		db.query("DELETE FROM workdir_dirty_dirs WHERE session_id = ?").run(sessionId);
 		db.query("DELETE FROM workdir_changes WHERE session_id = ?").run(sessionId);
 		db.query("DELETE FROM workdir_nodes WHERE session_id = ?").run(sessionId);
 		db.query("DELETE FROM workdir_sessions WHERE session_id = ?").run(sessionId);
@@ -286,6 +359,67 @@ function readNodeOrigin(row) {
 	}
 	throw new Error(`Invalid SQLite workdir node origin kind: ${row.origin_kind}`);
 }
+function readChangeRecord(row) {
+	return {
+		path: row.path,
+		previous: row.previous_kind === null || row.previous_mode === null || row.previous_hash === null ? null : {
+			kind: readDiffObjectKind(row.previous_kind),
+			mode: readDiffObjectMode(row.previous_mode),
+			hash: row.previous_hash
+		},
+		current: row.current_kind === null || row.current_mode === null || row.current_hash === null ? null : {
+			kind: readDiffObjectKind(row.current_kind),
+			mode: readDiffObjectMode(row.current_mode),
+			hash: row.current_hash
+		},
+		source: row.source_kind === null || row.source_path === null ? null : {
+			kind: readDiffSourceKind(row.source_kind),
+			path: row.source_path
+		}
+	};
+}
+function readDiffObjectKind(raw) {
+	if (raw === "blob" || raw === "symlink") return raw;
+	throw new Error(`Invalid SQLite workdir diff object kind: ${raw}`);
+}
+function readDiffObjectMode(raw) {
+	if (raw === "100644" || raw === "100755" || raw === "120000") return raw;
+	throw new Error(`Invalid SQLite workdir diff object mode: ${raw}`);
+}
+function readDiffSourceKind(raw) {
+	if (raw === "rename" || raw === "copy") return raw;
+	throw new Error(`Invalid SQLite workdir diff source kind: ${raw}`);
+}
+function readDirtyDirSummary(row) {
+	const affectedNames = readDirtyDirAffectedNames(row.affected_names);
+	return {
+		path: row.path,
+		isDirty: row.is_dirty !== 0,
+		dirtyEntryCount: readDirtyDirCount(row.dirty_entry_count, "dirty_entry_count"),
+		dirtyDescendantCount: readDirtyDirCount(row.dirty_descendant_count, "dirty_descendant_count"),
+		affectedNames,
+		currentTreeHash: row.current_tree_hash === null ? null : sha1(row.current_tree_hash),
+		hashState: readDirtyDirHashState(row.hash_state)
+	};
+}
+function readDirtyDirCount(raw, field) {
+	if (!Number.isInteger(raw) || raw < 0) throw new Error(`Invalid SQLite workdir dirty dir ${field}: ${raw}`);
+	return raw;
+}
+function readDirtyDirAffectedNames(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("Invalid SQLite workdir dirty dir affected_names JSON");
+	}
+	if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) throw new Error("Invalid SQLite workdir dirty dir affected_names payload");
+	return [...parsed].sort((left, right) => left.localeCompare(right));
+}
+function readDirtyDirHashState(raw) {
+	if (raw === "stale" || raw === "materialized") return raw;
+	throw new Error(`Invalid SQLite workdir dirty dir hash state: ${raw}`);
+}
 function readDirectoryOverlay(raw) {
 	if (raw === null) return {
 		addedEntries: /* @__PURE__ */ new Map(),
@@ -326,38 +460,5 @@ function isDirectoryOverlayPayload(value) {
 	const hasValidDeletedNames = maybe.deletedNames.every((name) => typeof name === "string");
 	return hasValidAddedEntries && hasValidDeletedNames;
 }
-function getRecordPath(record) {
-	switch (record.op) {
-		case "add":
-		case "modify":
-		case "delete":
-		case "revert": return record.path;
-		case "rename":
-		case "copy": return record.to;
-		default: return record;
-	}
-}
-function getRecordOldPath(record) {
-	if (record.op === "rename" || record.op === "copy") return record.from;
-	return null;
-}
-function readChangeRecord(row) {
-	switch (row.op) {
-		case "add":
-		case "modify":
-		case "delete":
-		case "revert": return {
-			op: row.op,
-			path: row.path
-		};
-		case "rename":
-		case "copy": return {
-			op: row.op,
-			from: row.old_path,
-			to: row.path
-		};
-		default: throw new Error(`Unknown workdir change op: ${row.op}`);
-	}
-}
 //#endregion
 export { createSqliteVirtualWorkdirBackend };

package/dist/workdir/state-store.d.mts

@@ -1,6 +1,7 @@
 import { SHA1 } from "../core/types.mjs";
-import { InternalChangeRecord } from "./change-log.mjs";
 import { NodeId } from "./ids.mjs";
+import { NormalizedChangeRecord } from "./change-index.mjs";
+import { DirtyDirSummary } from "./dirty-dir.mjs";
 import { SessionNode } from "./nodes.mjs";
 
 //#region src/workdir/state-store.d.ts
@@ -27,16 +28,26 @@ interface VirtualWorkdirStateStore {
   setNode(node: SessionNode): void;
   /** 删除节点 */
   deleteNode(id: NodeId): void;
-  /** 追加内部变更记录 */
-  appendChange(record: InternalChangeRecord): void;
-  /** 列出内部变更记录快照 */
-  listChangeRecords(): readonly InternalChangeRecord[];
-  /** 清空变更记录 */
-  clearChanges(): void;
+  /** 列出全部规范化变更记录 */
+  listChangeRecords(): readonly NormalizedChangeRecord[];
+  /** 按路径读取规范化变更记录 */
+  getChangeRecord(path: string): NormalizedChangeRecord | null;
+  /** 写入或覆盖规范化变更记录 */
+  setChangeRecord(record: NormalizedChangeRecord): void;
+  /** 删除规范化变更记录 */
+  deleteChangeRecord(path: string): void;
+  /** 列出全部脏目录摘要 */
+  listDirtyDirSummaries(): readonly DirtyDirSummary[];
+  /** 按目录路径读取脏目录摘要 */
+  getDirtyDirSummary(path: string): DirtyDirSummary | null;
+  /** 写入或覆盖脏目录摘要 */
+  setDirtyDirSummary(summary: DirtyDirSummary): void;
+  /** 删除脏目录摘要 */
+  deleteDirtyDirSummary(path: string): void;
   /**
    * 重置为新的基线 tree
    *
-   * 需要同时清空节点状态与变更记录，并重新建立根节点。
+   * 需要同时清空节点状态，并重新建立根节点。
    */
   reset(baseTree: SHA1): void;
 }

package/dist/workdir/write-tree.mjs

@@ -1,6 +1,8 @@
 import { writeObject } from "../objects/raw.mjs";
-import { isDirectoryOverlayDirty } from "./nodes.mjs";
+import { readRepoTree } from "./origin.mjs";
 import { listDirectoryChildren } from "./session-internal.mjs";
+import { createNamedOriginChildLookup, observeListedDirectoryChild, observeNamedDirectoryChild, planAffectedDirectoryChildren } from "./directory-view.mjs";
+import { materializeDirtyDirSummary } from "./dirty-dir.mjs";
 //#region src/workdir/write-tree.ts
 /**
 * Virtual Workdir overlay -> tree 最小化编译
@@ -35,63 +37,125 @@ function writeTreeFromSession(source, state) {
 *
 * 返回新 tree 的 SHA-1（若目录无任何变化则直接复用 origin hash）。
 */
-function compileDirectory(writeSource, readSource, state, dirNode) {
+function compileDirectory(writeSource, readSource, state, dirNode, dirPath = "") {
 	if (dirNode.state.kind !== "directory") throw new Error("compileDirectory called on non-directory node");
-	const children = listDirectoryChildren(readSource, state, dirNode, "");
+	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 = [];
-	for (const child of children) {
-		const node = state.getNode(child.nodeId);
-		if (node === null) continue;
-		if (node.state.kind === "directory") {
-			const newHash = compileDirectory(writeSource, readSource, state, node);
-			if (newHash !== (node.origin.kind === "repo-tree" ? node.origin.hash : null)) anyChanged = true;
-			newEntries.push({
+	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 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;
+		}
+		const compiled = compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, planEntry.name, originLookup);
+		if (compiled === null) continue;
+		markChanged(compiled.changed);
+		out.push(compiled.entry);
+	}
+	return out;
+}
+function collectAffectedChildNames(summary) {
+	return new Set(summary.affectedNames);
+}
+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 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: "40000",
 				name: child.name,
 				hash: newHash
+			},
+			changed: newHash !== originHash
+		};
+	}
+	if (node.state.kind === "file") {
+		if (node.state.content !== void 0) {
+			const hash = writeObject(writeSource, {
+				type: "blob",
+				content: node.state.content
 			});
-		} else if (node.state.kind === "file") {
-			if (node.state.content !== void 0) {
-				const hash = writeObject(writeSource, {
-					type: "blob",
-					content: node.state.content
-				});
-				anyChanged = true;
-				newEntries.push({
+			return {
+				entry: {
 					mode: node.state.mode,
 					name: child.name,
 					hash
-				});
-			} else if (node.origin.kind === "repo-blob") newEntries.push({
+				},
+				changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+			};
+		}
+		if (node.origin.kind === "repo-blob") return {
+			entry: {
 				mode: node.state.mode,
 				name: child.name,
 				hash: node.origin.hash
-			});
-		} else if (node.state.target !== void 0) {
-			const hash = writeObject(writeSource, {
-				type: "blob",
-				content: node.state.target
-			});
-			anyChanged = true;
-			newEntries.push({
+			},
+			changed: false
+		};
+		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
-			});
-		} else if (node.origin.kind === "repo-blob") newEntries.push({
+			},
+			changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+		};
+	}
+	if (node.origin.kind === "repo-blob") return {
+		entry: {
 			mode: "120000",
 			name: child.name,
 			hash: node.origin.hash
-		});
-	}
-	if (isDirectoryOverlayDirty(dirNode.state.overlay)) anyChanged = true;
-	if (!anyChanged && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
-	newEntries.sort((a, b) => a.name.localeCompare(b.name));
-	return writeObject(writeSource, {
-		type: "tree",
-		entries: newEntries
-	});
+		},
+		changed: false
+	};
+	return null;
 }
 //#endregion
 export { writeTreeFromSession };