@devosurf/vynt 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devosurf/vynt",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "files": [
     "bin",

package/src/bridge.ts

@@ -383,14 +383,9 @@ async function applySelectionsWithActiveRollback(
       throw error
     }
 
-    const allowDirtyFiles = collectActiveSelectionChangedFiles(state)
-    if (allowDirtyFiles.length === 0) {
-      throw new Error(
-        `${message}. No active changedFiles available for safe auto-rollback; run rollback first or register variants with changed files.`,
-      )
-    }
-
-    await rollbackWorkspaceToSnapshot(projectRoot, undefined, { allowDirtyFiles })
+    await rollbackWorkspaceToSnapshot(projectRoot, undefined, {
+      allowDirtyFiles: collectActiveSelectionChangedFiles(state),
+    })
     return applySelectionsToWorkspace(projectRoot, state.baseRef, selections)
   }
 }

package/src/switch.ts

@@ -24,10 +24,6 @@ export interface StoredSwitchSnapshot extends SwitchSnapshot {
   filePath: string
 }
 
-export interface RollbackWorkspaceOptions {
-  allowDirtyFiles?: string[]
-}
-
 async function runGit(projectRoot: string, args: string[]): Promise<string> {
   try {
     const { stdout } = await execFileAsync("git", args, {
@@ -94,18 +90,65 @@ async function listDirtyTrackedFiles(projectRoot: string): Promise<string[]> {
   return [...new Set(files)]
 }
 
-async function ensureRollbackSafety(projectRoot: string, allowDirtyFiles: string[]): Promise<void> {
+async function listFilesFromPatch(patchFile: string): Promise<string[]> {
+  const raw = await readFile(patchFile, "utf8")
+  const matches = raw.matchAll(/^diff --git a\/(.+?) b\/(.+)$/gm)
+  const files = new Set<string>()
+
+  for (const match of matches) {
+    const fromPath = normalizeRepoPath(match[1] ?? "")
+    const toPath = normalizeRepoPath(match[2] ?? "")
+
+    if (toPath.length > 0 && toPath !== "dev/null") {
+      files.add(toPath)
+      continue
+    }
+
+    if (fromPath.length > 0 && fromPath !== "dev/null") {
+      files.add(fromPath)
+    }
+  }
+
+  return [...files]
+}
+
+async function collectRollbackTargetFiles(snapshot: StoredSwitchSnapshot): Promise<string[]> {
+  const fromMetadata = snapshot.selections
+    .flatMap((selection) => selection.changedFiles ?? [])
+    .map(normalizeRepoPath)
+    .filter((file) => file.length > 0)
+
+  const fromPatchFiles = await Promise.all(snapshot.selections.map((selection) => listFilesFromPatch(selection.patchFile)))
+  const flattenedPatchFiles = fromPatchFiles.flat().map(normalizeRepoPath).filter((file) => file.length > 0)
+
+  return [...new Set([...fromMetadata, ...flattenedPatchFiles])]
+}
+
+async function ensureRollbackSafety(
+  projectRoot: string,
+  rollbackTargetFiles: string[],
+  allowDirtyFiles: string[],
+): Promise<void> {
   const dirtyFiles = await listDirtyTrackedFiles(projectRoot)
   if (dirtyFiles.length === 0) return
 
-  const allowed = new Set(allowDirtyFiles.map(normalizeRepoPath))
-  const disallowed = dirtyFiles.filter((file) => !allowed.has(normalizeRepoPath(file)))
+  const normalizedTargets = new Set(rollbackTargetFiles.map(normalizeRepoPath).filter((file) => file.length > 0))
+  if (normalizedTargets.size === 0) {
+    await ensureCleanWorkspace(projectRoot)
+    return
+  }
+
+  const overlapping = dirtyFiles.filter((file) => normalizedTargets.has(normalizeRepoPath(file)))
+  if (overlapping.length === 0) return
+
+  const allowed = new Set(allowDirtyFiles.map(normalizeRepoPath).filter((file) => file.length > 0))
+  const disallowed = overlapping.filter((file) => !allowed.has(normalizeRepoPath(file)))
   if (disallowed.length === 0) return
 
   const listed = disallowed.slice(0, 5).join(", ")
   const remainder = disallowed.length > 5 ? `, +${disallowed.length - 5} more` : ""
   throw new Error(
-    `Rollback would overwrite uncommitted changes outside active variant files: ${listed}${remainder}. Commit or stash these changes before rollback.`,
+    `Rollback would overwrite uncommitted changes in files touched by the snapshot: ${listed}${remainder}. Commit or stash these changes before rollback.`,
   )
 }
 
@@ -159,6 +202,9 @@ function parseSnapshot(content: unknown, filePath: string): StoredSwitchSnapshot
       objectiveId: item.objectiveId,
       variantId: item.variantId,
       patchFile: item.patchFile,
+      changedFiles: Array.isArray(item.changedFiles)
+        ? item.changedFiles.filter((file): file is string => typeof file === "string")
+        : undefined,
     }
   })
 
@@ -329,10 +375,14 @@ export async function rollbackWorkspaceToSnapshot(
     throw new Error("No snapshots found. Run apply/profile apply first.")
   }
 
-  await ensureRollbackSafety(projectRoot, options.allowDirtyFiles ?? [])
+  const rollbackTargetFiles = await collectRollbackTargetFiles(snapshot)
+  await ensureRollbackSafety(projectRoot, rollbackTargetFiles, options.allowDirtyFiles ?? [])
 
   await verifyBaseRef(projectRoot, snapshot.head)
-  await restoreWorkspaceToBase(projectRoot, snapshot.head)
+  await restoreWorkspaceToBase(projectRoot, snapshot.head, rollbackTargetFiles)
 
   return { snapshot }
 }
+export interface RollbackWorkspaceOptions {
+  allowDirtyFiles?: string[]
+}