@davideasden/pi-undo 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@davideasden/pi-undo",
-	"version": "0.2.1",
+	"version": "0.2.2",
 	"description": "Persistent workspace undo and redo for Pi",
 	"type": "module",
 	"keywords": [

package/src/controller.ts

@@ -406,6 +406,9 @@ export class UndoControllerImpl implements UndoController {
 			} catch {
 				return done({ code: "busy", changedFiles: 0 });
 			}
+			if (checkpoint.changedPaths.length === 0) {
+				return done(await this.runSessionOnlyOperation(action, checkpoint, targetManifestId, profile));
+			}
 			let rollback: SnapshotManifest;
 			try {
 				rollback = await profile.measure("capture", () =>
@@ -492,6 +495,84 @@ export class UndoControllerImpl implements UndoController {
 		}
 	}
 
+	private async runSessionOnlyOperation(
+		action: "undo" | "redo",
+		checkpoint: CheckpointRecord,
+		targetManifestId: ManifestId | undefined,
+		profile: OperationProfiler,
+	): Promise<OperationResult> {
+		const rollbackManifestId = action === "undo"
+			? checkpoint.afterManifestId
+			: checkpoint.beforeManifestId;
+		const targetId = targetManifestId ?? (
+			action === "undo" ? checkpoint.beforeManifestId : checkpoint.afterManifestId
+		);
+		const plan = emptyRestorePlan(rollbackManifestId, targetId);
+		const targetLogicalLeaf = this.dependencies.resolveSessionTarget(action, checkpoint);
+		const descriptor = this.createDescriptorFromManifestIds(
+			action,
+			rollbackManifestId,
+			targetId,
+			plan,
+			targetLogicalLeaf,
+		);
+		await profile.measure("journal", () => this.dependencies.journal.prepare(descriptor, plan));
+		const navigation = await profile.measure("navigate", () =>
+			this.dependencies.navigateSession(action, checkpoint));
+		if (navigation.cancelled) {
+			await profile.measure("journal", async () => {
+				await this.dependencies.journal.setPhase(descriptor.opId, "ABORTING");
+				await this.dependencies.journal.setPhase(descriptor.opId, "ABORTED");
+			});
+			return { code: "restore_failed_safe", changedFiles: 0 };
+		}
+		if (navigation.logicalLeafId !== descriptor.toLogicalLeaf) {
+			this.locked = true;
+			await profile.measure("journal", () =>
+				this.dependencies.journal.setPhase(descriptor.opId, "RECOVERY_REQUIRED"));
+			return { code: "recovery_required", changedFiles: 0 };
+		}
+		await profile.measure("journal", async () => {
+			await this.dependencies.journal.setPhase(descriptor.opId, "SESSION_MOVED", {
+				observedLogicalLeaf: navigation.logicalLeafId,
+			});
+			await this.dependencies.journal.setPhase(descriptor.opId, "APPLYING");
+			await this.dependencies.journal.setPhase(descriptor.opId, "FILES_VERIFIED");
+		});
+		const cursorResult = await profile.measure("cursor", () =>
+			this.dependencies.appendCursor(this.createCursor(descriptor, action, checkpoint)));
+		if (cursorResult.kind === "recovery_required") {
+			this.locked = true;
+			await profile.measure("journal", () =>
+				this.dependencies.journal.setPhase(descriptor.opId, "RECOVERY_REQUIRED").catch(() => {}));
+			return { code: "recovery_required", changedFiles: 0 };
+		}
+		if (cursorResult.kind === "volatile") {
+			return profile.measure("compensate", () => this.compensateSessionOnly(descriptor));
+		}
+		await profile.measure("commit", async () => {
+			await this.dependencies.journal.setPhase(descriptor.opId, "CURSOR_COMMITTED");
+			await this.dependencies.journal.markCommitted(descriptor.opId);
+		});
+		this.lastSafetyManifestId = rollbackManifestId;
+		return { code: "ok", changedFiles: 0 };
+	}
+
+	private async compensateSessionOnly(descriptor: OperationDescriptor): Promise<OperationResult> {
+		try {
+			await this.dependencies.journal.setPhase(descriptor.opId, "ABORTING");
+			if (!await this.dependencies.restoreSessionLeaf(descriptor.fromLogicalLeaf)) {
+				throw new Error("session rollback failed");
+			}
+			await this.dependencies.journal.setPhase(descriptor.opId, "ABORTED");
+			return { code: "restore_failed_safe", changedFiles: 0 };
+		} catch {
+			this.locked = true;
+			await this.dependencies.journal.setPhase(descriptor.opId, "RECOVERY_REQUIRED").catch(() => {});
+			return { code: "recovery_required", changedFiles: 0 };
+		}
+	}
+
 	private async ensureIdle(): Promise<boolean> {
 		if (this.dependencies.isAgentIdle()) return true;
 		try {
@@ -569,6 +650,22 @@ export class UndoControllerImpl implements UndoController {
 		target: SnapshotManifest,
 		plan: RestorePlan,
 		targetLogicalLeaf: string | null,
+	): OperationDescriptor {
+		return this.createDescriptorFromManifestIds(
+			action,
+			rollback.manifestId,
+			target.manifestId,
+			plan,
+			targetLogicalLeaf,
+		);
+	}
+
+	private createDescriptorFromManifestIds(
+		action: "undo" | "redo" | "tree",
+		rollbackManifestId: ManifestId,
+		targetManifestId: ManifestId,
+		plan: RestorePlan,
+		targetLogicalLeaf: string | null,
 	): OperationDescriptor {
 		const scopePaths = [...(plan.scopePaths ?? [...plan.deletePaths, ...plan.writePaths])].sort();
 		const payload = {
@@ -579,8 +676,8 @@ export class UndoControllerImpl implements UndoController {
 			action,
 			fromLogicalLeaf: this.dependencies.getLogicalLeafId(),
 			toLogicalLeaf: targetLogicalLeaf,
-			targetManifestId: target.manifestId,
-			rollbackManifestId: rollback.manifestId,
+			targetManifestId,
+			rollbackManifestId,
 			coverage: `paths:${checksum(canonicalJson(scopePaths))}`,
 			scopePaths,
 			planDigest: plan.planDigest,
@@ -633,6 +730,18 @@ export class UndoControllerImpl implements UndoController {
 	}
 }
 
+function emptyRestorePlan(currentManifestId: ManifestId, targetManifestId: ManifestId): RestorePlan {
+	const payload = {
+		currentManifestId,
+		targetManifestId,
+		boundaryRoots: [],
+		deletePaths: [],
+		writePaths: [],
+		scopePaths: [],
+	};
+	return { ...payload, planDigest: checksum(canonicalJson(payload)) };
+}
+
 class OperationProfiler {
 	private readonly durations = new Map<string, number>();
 

package/src/pi-runtime.ts

@@ -59,8 +59,15 @@ export async function createPiUndoRuntime(context: ExtensionContext, pi: Extensi
 		recoverMutations: async (pending, decision) => {
 			const mutationJournal = journal.mutationJournal(pending.descriptor.opId);
 			const quarantine = new QuarantineManager({ workspaceRoot: context.cwd, journal: mutationJournal });
-			try {
-				const records = (await mutationJournal.load()).filter((record) => record.state !== "CLEANED");
+				try {
+				const loaded = await mutationJournal.load();
+				const scopePaths = pending.descriptor.scopePaths;
+				if (loaded.some((record) => !scopePaths.some((scope) =>
+					scope === "." || record.path === scope || record.path.startsWith(`${scope}/`)
+				))) {
+					throw new Error("mutation journal path 超出 descriptor scope");
+				}
+				const records = loaded.filter((record) => record.state !== "CLEANED");
 				if (decision === "rollback") records.reverse();
 				for (const record of records) {
 					if (decision === "rollback") {

package/src/recovery.ts

@@ -100,19 +100,21 @@ export class JournalRecovery {
 			}
 
 			try {
-				const current = await this.dependencies.capture();
-				const targetId = inspection.kind === "match"
-					? journal.descriptor.targetManifestId
-					: journal.descriptor.rollbackManifestId;
-				const target = await this.dependencies.loadManifest(targetId);
-				const plan = await this.dependencies.planRestore(current, target, journal.descriptor.scopePaths);
-				const applied = await this.dependencies.applyRestore(
-					plan,
-					target,
-					{ opId: journal.descriptor.opId },
-				);
-				if (applied.code !== "ok") {
-					return { kind: "locked", reason: "restore_failed", operations: recovered };
+				if (journal.descriptor.scopePaths.length > 0) {
+					const current = await this.dependencies.capture();
+					const targetId = inspection.kind === "match"
+						? journal.descriptor.targetManifestId
+						: journal.descriptor.rollbackManifestId;
+					const target = await this.dependencies.loadManifest(targetId);
+					const plan = await this.dependencies.planRestore(current, target, journal.descriptor.scopePaths);
+					const applied = await this.dependencies.applyRestore(
+						plan,
+						target,
+						{ opId: journal.descriptor.opId },
+					);
+					if (applied.code !== "ok") {
+						return { kind: "locked", reason: "restore_failed", operations: recovered };
+					}
 				}
 				if (inspection.kind === "match") {
 					await this.dependencies.finalizeCursor(journal, inspection);