@devosurf/vynt 0.1.3 → 0.1.5

package/package.json

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

package/src/bridge.ts

@@ -1,6 +1,6 @@
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http"
 import { watch, type FSWatcher } from "node:fs"
-import { readFile } from "node:fs/promises"
+import { readFile, unlink } from "node:fs/promises"
 import { dirname, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
 import { applySelectionsToWorkspace, getLatestSnapshot, rollbackWorkspaceToSnapshot } from "./switch.js"
@@ -187,12 +187,18 @@ function markVariantSelectedInState(state: VariantStore, objectiveId: string, va
   }
 }
 
-function finalizeVariantInObjectiveState(state: VariantStore, objectiveId: string, variantId: string): VariantStore {
+function finalizeVariantInObjectiveState(
+  state: VariantStore,
+  objectiveId: string,
+  variantId: string,
+): { nextState: VariantStore; removedVariants: VariantArtifact[] } {
   const objectiveItem = findObjective(state, objectiveId)
-  findVariant(objectiveItem, variantId)
+  const winner = findVariant(objectiveItem, variantId)
   const now = new Date().toISOString()
+  const removedVariants = objectiveItem.variants.filter((variant) => variant.id !== variantId)
 
   return {
+    nextState: {
     ...state,
     activeProfileId: undefined,
     objectives: state.objectives.map((item) => {
@@ -204,23 +210,49 @@ function finalizeVariantInObjectiveState(state: VariantStore, objectiveId: strin
         winnerVariantId: variantId,
         status: "finalized" as const,
         updatedAt: now,
-        variants: objectiveItem.variants.map((variant) => {
-          if (variant.id === variantId) {
-            return {
-              ...variant,
-              status: "selected" as const,
-              updatedAt: now,
-            }
-          }
-
-          return {
-            ...variant,
-            status: "archived" as const,
+        variants: [
+          {
+            ...winner,
+            status: "selected" as const,
             updatedAt: now,
-          }
-        }),
+          },
+        ],
       }
     }),
+    },
+    removedVariants,
+  }
+}
+
+function collectPatchFiles(state: VariantStore): Set<string> {
+  const files = new Set<string>()
+  for (const objective of state.objectives) {
+    for (const variant of objective.variants) {
+      files.add(variant.patchFile)
+    }
+  }
+  return files
+}
+
+async function pruneRemovedVariantPatchFiles(
+  nextState: VariantStore,
+  removedVariants: VariantArtifact[],
+): Promise<void> {
+  if (removedVariants.length === 0) return
+  const retainedPatchFiles = collectPatchFiles(nextState)
+  const deleteCandidates = new Set<string>()
+
+  for (const variant of removedVariants) {
+    if (!retainedPatchFiles.has(variant.patchFile)) {
+      deleteCandidates.add(variant.patchFile)
+    }
+  }
+
+  for (const patchFile of deleteCandidates) {
+    try {
+      await unlink(patchFile)
+    } catch {
+    }
   }
 }
 
@@ -351,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)
   }
 }
@@ -743,7 +770,9 @@ export async function startBridgeServer(options: StartBridgeServerOptions): Prom
           },
         ])
 
-        const nextState = finalizeVariantInObjectiveState(state, target.objective.id, target.variant.id)
+        const finalized = finalizeVariantInObjectiveState(state, target.objective.id, target.variant.id)
+        await pruneRemovedVariantPatchFiles(finalized.nextState, finalized.removedVariants)
+        const nextState = finalized.nextState
         await saveState(projectRoot, nextState)
 
         emitEvent("finalize.succeeded", {

package/src/cli.ts

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process"
-import { access, mkdir, readFile, writeFile } from "node:fs/promises"
+import { access, mkdir, readFile, unlink, writeFile } from "node:fs/promises"
 import { basename, join, resolve } from "node:path"
 import process from "node:process"
 import { createInterface } from "node:readline/promises"
@@ -544,6 +544,38 @@ function findProfile(state: VariantStore, profileId: string): PreviewProfile {
   return found
 }
 
+function collectPatchFiles(state: VariantStore): Set<string> {
+  const files = new Set<string>()
+  for (const objective of state.objectives) {
+    for (const variant of objective.variants) {
+      files.add(variant.patchFile)
+    }
+  }
+  return files
+}
+
+async function pruneRemovedVariantPatchFiles(
+  nextState: VariantStore,
+  removedVariants: VariantArtifact[],
+): Promise<void> {
+  if (removedVariants.length === 0) return
+  const retainedPatchFiles = collectPatchFiles(nextState)
+  const deleteCandidates = new Set<string>()
+
+  for (const variant of removedVariants) {
+    if (!retainedPatchFiles.has(variant.patchFile)) {
+      deleteCandidates.add(variant.patchFile)
+    }
+  }
+
+  for (const patchFile of deleteCandidates) {
+    try {
+      await unlink(patchFile)
+    } catch {
+    }
+  }
+}
+
 function findVariantAcrossObjectives(
   state: VariantStore,
   variantId: string,
@@ -829,17 +861,26 @@ function createProgram(cwd: string): Command {
     .action(async (objectiveId: string, variantId: string) => {
       const state = requireState(await loadState(cwd))
       const current = findObjective(state, objectiveId)
-      findVariant(current, variantId)
+      const winner = findVariant(current, variantId)
+      const removedVariants = current.variants.filter((variant) => variant.id !== variantId)
 
       const now = new Date().toISOString()
       const next = upsertObjective(state, {
         ...current,
         status: "finalized",
         winnerVariantId: variantId,
-        activeVariantId: current.activeVariantId ?? variantId,
+        activeVariantId: variantId,
         updatedAt: now,
+        variants: [
+          {
+            ...winner,
+            status: "selected",
+            updatedAt: now,
+          },
+        ],
       })
 
+      await pruneRemovedVariantPatchFiles(next, removedVariants)
       await saveState(cwd, next)
       process.stdout.write(`Objective ${objectiveId} finalized with winner ${variantId}\n`)
     })

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[]
+}

package/web/vynt-toolbar.js

@@ -576,13 +576,35 @@
     objectiveOverlayRoot.style.width = `${Math.max(0, width)}px`;
     objectiveOverlayRoot.style.height = `${Math.max(0, height)}px`;
 
-    const panelBottom = -50;
-    if (y + height + panelBottom + 48 > window.innerHeight) {
-      objectivePanel.style.bottom = "auto";
-      objectivePanel.style.top = "-50px";
+    const panelGap = 8;
+    const panelWidth = 220;
+    const panelHeight = 40;
+    const rightSpace = window.innerWidth - (x + width);
+    const leftSpace = x;
+    const alignedTop = Math.max(0, Math.min(Math.max(0, height - panelHeight), (height - panelHeight) / 2));
+
+    objectivePanel.style.bottom = "auto";
+    objectivePanel.style.top = `${alignedTop}px`;
+
+    if (rightSpace >= panelWidth + panelGap) {
+      objectivePanel.style.left = `${width + panelGap}px`;
+      objectivePanel.style.transform = "none";
+      return;
+    }
+
+    if (leftSpace >= panelWidth + panelGap) {
+      objectivePanel.style.left = `${-panelGap}px`;
+      objectivePanel.style.transform = "translateX(-100%)";
+      return;
+    }
+
+    objectivePanel.style.left = "50%";
+    objectivePanel.style.transform = "translateX(-50%)";
+    if (y + height + panelGap + panelHeight > window.innerHeight) {
+      objectivePanel.style.top = `${-panelGap}px`;
+      objectivePanel.style.transform = "translate(-50%, -100%)";
     } else {
-      objectivePanel.style.top = "auto";
-      objectivePanel.style.bottom = "-50px";
+      objectivePanel.style.top = `${height + panelGap}px`;
     }
   }