@devosurf/vynt 0.1.2

package/src/state.ts

@@ -0,0 +1,167 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { dirname, resolve } from "node:path"
+import type { Objective, PreviewProfile, VariantArtifact, VariantStore } from "./types.js"
+
+const STATE_DIR = ".vynt"
+const STATE_FILE = "state.json"
+
+export function getStatePath(projectRoot: string): string {
+  return resolve(projectRoot, STATE_DIR, STATE_FILE)
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+function migrateState(input: unknown, projectRoot: string): VariantStore | undefined {
+  if (!isObject(input)) return undefined
+  if (typeof input.baseRef !== "string" || input.baseRef.trim().length === 0) return undefined
+  const baseRef = input.baseRef
+
+  if (input.schemaVersion === 2 && Array.isArray(input.objectives) && Array.isArray(input.profiles)) {
+    return {
+      ...(input as unknown as VariantStore),
+      projectRoot: resolve(projectRoot),
+    }
+  }
+
+  const now = new Date().toISOString()
+  const legacyVariants = Array.isArray(input.variants) ? input.variants : []
+  const activeVariantId = typeof input.activeVariantId === "string" ? input.activeVariantId : undefined
+
+  const variants: VariantArtifact[] = legacyVariants
+    .filter(isObject)
+    .map((item, index) => {
+      const id = typeof item.id === "string" && item.id.trim().length > 0 ? item.id : `legacy-${index + 1}`
+      const name = typeof item.name === "string" && item.name.trim().length > 0 ? item.name : id
+      const patchFile = typeof item.patchFile === "string" ? item.patchFile : ""
+      const changedFiles = Array.isArray(item.changedFiles)
+        ? item.changedFiles.filter((entry): entry is string => typeof entry === "string")
+        : []
+      const screenshots = Array.isArray(item.screenshots)
+        ? item.screenshots.filter((entry): entry is string => typeof entry === "string")
+        : []
+      const status: VariantArtifact["status"] =
+        item.status === "draft" ||
+        item.status === "running" ||
+        item.status === "ready" ||
+        item.status === "selected" ||
+        item.status === "archived"
+          ? item.status
+          : "ready"
+
+      return {
+        id,
+        objectiveId: "legacy",
+        name,
+        baseRef,
+        patchFile,
+        changedFiles,
+        sessionId: typeof item.sessionId === "string" ? item.sessionId : undefined,
+        screenshots,
+        notes: typeof item.notes === "string" ? item.notes : undefined,
+        status,
+        createdAt: typeof item.createdAt === "string" ? item.createdAt : now,
+        updatedAt: typeof item.updatedAt === "string" ? item.updatedAt : now,
+      }
+    })
+    .filter((item) => item.patchFile.length > 0)
+
+  const objectives: Objective[] =
+    variants.length > 0
+      ? [
+          {
+            id: "legacy",
+            name: "legacy",
+            baseRef,
+            status: "open",
+            activeVariantId,
+            variants,
+            createdAt: now,
+            updatedAt: now,
+          },
+        ]
+      : []
+
+  return {
+    schemaVersion: 2,
+    projectRoot: resolve(projectRoot),
+    baseRef,
+    objectives,
+    profiles: [],
+  }
+}
+
+export async function loadState(projectRoot: string): Promise<VariantStore | undefined> {
+  const statePath = getStatePath(projectRoot)
+
+  try {
+    const content = await readFile(statePath, "utf8")
+    return migrateState(JSON.parse(content), projectRoot)
+  } catch {
+    return undefined
+  }
+}
+
+export async function saveState(projectRoot: string, state: VariantStore): Promise<void> {
+  const statePath = getStatePath(projectRoot)
+  await mkdir(dirname(statePath), { recursive: true })
+  await writeFile(statePath, JSON.stringify(state, null, 2) + "\n", "utf8")
+}
+
+export function createEmptyStore(projectRoot: string, baseRef: string): VariantStore {
+  return {
+    schemaVersion: 2,
+    projectRoot: resolve(projectRoot),
+    baseRef,
+    objectives: [],
+    profiles: [],
+  }
+}
+
+export function upsertObjective(state: VariantStore, objective: Objective): VariantStore {
+  const next = [...state.objectives]
+  const index = next.findIndex((item) => item.id === objective.id)
+
+  if (index >= 0) next[index] = objective
+  else next.push(objective)
+
+  return {
+    ...state,
+    objectives: next,
+  }
+}
+
+export function upsertProfile(state: VariantStore, profile: PreviewProfile): VariantStore {
+  const next = [...state.profiles]
+  const index = next.findIndex((item) => item.id === profile.id)
+
+  if (index >= 0) next[index] = profile
+  else next.push(profile)
+
+  return {
+    ...state,
+    profiles: next,
+  }
+}
+
+export function upsertVariant(state: VariantStore, variant: VariantArtifact): VariantStore {
+  return {
+    ...state,
+    objectives: state.objectives.map((objective) => {
+      if (objective.id !== variant.objectiveId) return objective
+
+      const variants = [...objective.variants]
+      const index = variants.findIndex((item) => item.id === variant.id)
+
+      if (index >= 0) variants[index] = variant
+      else variants.push(variant)
+
+      return {
+        ...objective,
+        variants,
+        updatedAt: new Date().toISOString(),
+      }
+    }),
+  }
+}

package/src/switch.ts

@@ -0,0 +1,338 @@
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises"
+import { join, resolve } from "node:path"
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+
+const execFileAsync = promisify(execFile)
+
+export interface ApplySelection {
+  objectiveId: string
+  variantId: string
+  patchFile: string
+  changedFiles?: string[]
+}
+
+export interface SwitchSnapshot {
+  id: string
+  createdAt: string
+  head: string
+  baseRef: string
+  selections: ApplySelection[]
+}
+
+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, {
+      cwd: projectRoot,
+      encoding: "utf8",
+    })
+    return stdout.trim()
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`git ${args.join(" ")} failed: ${message}`)
+  }
+}
+
+async function ensureGitWorkspace(projectRoot: string): Promise<void> {
+  const inside = await runGit(projectRoot, ["rev-parse", "--is-inside-work-tree"])
+  if (inside !== "true") {
+    throw new Error("Current directory is not inside a git worktree")
+  }
+}
+
+async function ensureCleanWorkspace(projectRoot: string): Promise<void> {
+  const status = await runGit(projectRoot, ["status", "--porcelain", "--untracked-files=no"])
+  if (status.length > 0) {
+    throw new Error("Workspace has uncommitted changes. Commit or stash changes before apply.")
+  }
+}
+
+async function ensureWorkspaceSafeForTargetFiles(projectRoot: string, targetFiles: string[]): Promise<void> {
+  const normalizedTargets = new Set(targetFiles.map(normalizeRepoPath))
+  if (normalizedTargets.size === 0) {
+    await ensureCleanWorkspace(projectRoot)
+    return
+  }
+
+  const dirtyFiles = await listDirtyTrackedFiles(projectRoot)
+  if (dirtyFiles.length === 0) return
+
+  const overlapping = dirtyFiles.filter((file) => normalizedTargets.has(normalizeRepoPath(file)))
+  if (overlapping.length === 0) return
+
+  const listed = overlapping.slice(0, 5).join(", ")
+  const remainder = overlapping.length > 5 ? `, +${overlapping.length - 5} more` : ""
+  throw new Error(
+    `Workspace has uncommitted changes in files affected by selected variant(s): ${listed}${remainder}. Commit, stash, or move these edits before switching variants.`,
+  )
+}
+
+function normalizeRepoPath(input: string): string {
+  return input.replace(/\\/g, "/").replace(/^\.\//, "")
+}
+
+function splitNonEmptyLines(input: string): string[] {
+  return input
+    .split(/\r?\n/g)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+}
+
+async function listDirtyTrackedFiles(projectRoot: string): Promise<string[]> {
+  const unstaged = await runGit(projectRoot, ["diff", "--name-only"])
+  const staged = await runGit(projectRoot, ["diff", "--name-only", "--cached"])
+
+  const files = [...splitNonEmptyLines(unstaged), ...splitNonEmptyLines(staged)].map(normalizeRepoPath)
+  return [...new Set(files)]
+}
+
+async function ensureRollbackSafety(projectRoot: 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)))
+  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.`,
+  )
+}
+
+async function ensurePatchFilesExist(selections: ApplySelection[]): Promise<void> {
+  for (const selection of selections) {
+    await access(selection.patchFile)
+  }
+}
+
+async function verifyBaseRef(projectRoot: string, baseRef: string): Promise<void> {
+  await runGit(projectRoot, ["rev-parse", "--verify", `${baseRef}^{commit}`])
+}
+
+function getSnapshotDir(projectRoot: string): string {
+  return resolve(projectRoot, ".vynt", "snapshots")
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+function parseSnapshot(content: unknown, filePath: string): StoredSwitchSnapshot {
+  if (!isObject(content)) {
+    throw new Error(`Invalid snapshot format: ${filePath}`)
+  }
+
+  if (
+    typeof content.id !== "string" ||
+    typeof content.createdAt !== "string" ||
+    typeof content.head !== "string" ||
+    typeof content.baseRef !== "string" ||
+    !Array.isArray(content.selections)
+  ) {
+    throw new Error(`Invalid snapshot payload: ${filePath}`)
+  }
+
+  const selections: ApplySelection[] = content.selections.map((item, index) => {
+    if (!isObject(item)) {
+      throw new Error(`Invalid snapshot selection at index ${index}: ${filePath}`)
+    }
+
+    if (
+      typeof item.objectiveId !== "string" ||
+      typeof item.variantId !== "string" ||
+      typeof item.patchFile !== "string"
+    ) {
+      throw new Error(`Invalid snapshot selection payload at index ${index}: ${filePath}`)
+    }
+
+    return {
+      objectiveId: item.objectiveId,
+      variantId: item.variantId,
+      patchFile: item.patchFile,
+    }
+  })
+
+  return {
+    id: content.id,
+    createdAt: content.createdAt,
+    head: content.head,
+    baseRef: content.baseRef,
+    selections,
+    filePath,
+  }
+}
+
+async function readSnapshotFile(filePath: string): Promise<StoredSwitchSnapshot> {
+  const raw = await readFile(filePath, "utf8")
+  return parseSnapshot(JSON.parse(raw), filePath)
+}
+
+function sortSnapshotsDescending(snapshots: StoredSwitchSnapshot[]): StoredSwitchSnapshot[] {
+  return [...snapshots].sort((left, right) => {
+    const leftTs = Date.parse(left.createdAt)
+    const rightTs = Date.parse(right.createdAt)
+
+    if (Number.isFinite(leftTs) && Number.isFinite(rightTs) && leftTs !== rightTs) {
+      return rightTs - leftTs
+    }
+
+    return right.id.localeCompare(left.id)
+  })
+}
+
+export async function listSnapshots(projectRoot: string): Promise<StoredSwitchSnapshot[]> {
+  const snapshotDir = getSnapshotDir(projectRoot)
+  let entries: string[]
+
+  try {
+    entries = await readdir(snapshotDir)
+  } catch (error: unknown) {
+    const code = (error as NodeJS.ErrnoException)?.code
+    if (code === "ENOENT") {
+      return []
+    }
+    throw error
+  }
+
+  const files = entries
+    .filter((entry) => entry.endsWith(".json"))
+    .map((entry) => join(snapshotDir, entry))
+
+  const snapshots = await Promise.all(files.map((filePath) => readSnapshotFile(filePath)))
+  return sortSnapshotsDescending(snapshots)
+}
+
+export async function getLatestSnapshot(projectRoot: string): Promise<StoredSwitchSnapshot | undefined> {
+  const snapshots = await listSnapshots(projectRoot)
+  return snapshots[0]
+}
+
+export async function getSnapshotById(
+  projectRoot: string,
+  snapshotId: string,
+): Promise<StoredSwitchSnapshot | undefined> {
+  const snapshots = await listSnapshots(projectRoot)
+  return snapshots.find((snapshot) => snapshot.id === snapshotId)
+}
+
+async function createSnapshot(projectRoot: string, baseRef: string, selections: ApplySelection[]): Promise<string> {
+  const createdAt = new Date().toISOString()
+  const head = await runGit(projectRoot, ["rev-parse", "HEAD"])
+  const snapshotId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+  const snapshotDir = getSnapshotDir(projectRoot)
+  const snapshotPath = join(snapshotDir, `${snapshotId}.json`)
+
+  const payload: SwitchSnapshot = {
+    id: snapshotId,
+    createdAt,
+    head,
+    baseRef,
+    selections,
+  }
+
+  await mkdir(snapshotDir, { recursive: true })
+  await writeFile(snapshotPath, JSON.stringify(payload, null, 2) + "\n", "utf8")
+  return snapshotPath
+}
+
+async function restoreWorkspaceToBase(projectRoot: string, baseRef: string, files?: string[]): Promise<void> {
+  const normalized = (files ?? []).map(normalizeRepoPath).filter((item) => item.length > 0)
+  if (normalized.length === 0) {
+    await runGit(projectRoot, ["restore", `--source=${baseRef}`, "--staged", "--worktree", "."])
+    return
+  }
+
+  await runGit(projectRoot, ["restore", `--source=${baseRef}`, "--staged", "--worktree", "--", ...normalized])
+}
+
+type PatchApplyMode = "plain" | "three-way"
+
+async function resolvePatchApplyMode(projectRoot: string, patchFile: string): Promise<PatchApplyMode> {
+  try {
+    await runGit(projectRoot, ["apply", "--check", patchFile])
+    return "plain"
+  } catch (plainError: unknown) {
+    try {
+      await runGit(projectRoot, ["apply", "--3way", "--check", patchFile])
+      return "three-way"
+    } catch (threeWayError: unknown) {
+      const plainMessage = plainError instanceof Error ? plainError.message : String(plainError)
+      const threeWayMessage = threeWayError instanceof Error ? threeWayError.message : String(threeWayError)
+      throw new Error(`${plainMessage}\n3-way fallback also failed: ${threeWayMessage}`)
+    }
+  }
+}
+
+async function applyPatch(projectRoot: string, patchFile: string, mode: PatchApplyMode): Promise<void> {
+  const args = mode === "three-way" ? ["apply", "--3way", patchFile] : ["apply", patchFile]
+  await runGit(projectRoot, args)
+}
+
+export async function applySelectionsToWorkspace(
+  projectRoot: string,
+  baseRef: string,
+  inputSelections: ApplySelection[],
+): Promise<{ snapshotPath: string }> {
+  if (inputSelections.length === 0) {
+    throw new Error("No variants selected for apply")
+  }
+
+  const selections = [...inputSelections].sort((left, right) => left.objectiveId.localeCompare(right.objectiveId))
+  const targetFiles = [...new Set(selections.flatMap((selection) => selection.changedFiles ?? []).map(normalizeRepoPath))]
+
+  await ensurePatchFilesExist(selections)
+  await ensureGitWorkspace(projectRoot)
+  await verifyBaseRef(projectRoot, baseRef)
+  await ensureWorkspaceSafeForTargetFiles(projectRoot, targetFiles)
+
+  const snapshotPath = await createSnapshot(projectRoot, baseRef, selections)
+  await restoreWorkspaceToBase(projectRoot, baseRef, targetFiles)
+
+  const executionPlan: Array<{ selection: ApplySelection; mode: PatchApplyMode }> = []
+  for (const selection of selections) {
+    const mode = await resolvePatchApplyMode(projectRoot, selection.patchFile)
+    executionPlan.push({ selection, mode })
+  }
+
+  for (const step of executionPlan) {
+    await applyPatch(projectRoot, step.selection.patchFile, step.mode)
+  }
+
+  return { snapshotPath }
+}
+
+export async function rollbackWorkspaceToSnapshot(
+  projectRoot: string,
+  snapshotId?: string,
+  options: RollbackWorkspaceOptions = {},
+): Promise<{ snapshot: StoredSwitchSnapshot }> {
+  await ensureGitWorkspace(projectRoot)
+
+  const snapshot = snapshotId
+    ? await getSnapshotById(projectRoot, snapshotId)
+    : await getLatestSnapshot(projectRoot)
+
+  if (!snapshot) {
+    if (snapshotId) {
+      throw new Error(`Snapshot not found: ${snapshotId}`)
+    }
+    throw new Error("No snapshots found. Run apply/profile apply first.")
+  }
+
+  await ensureRollbackSafety(projectRoot, options.allowDirtyFiles ?? [])
+
+  await verifyBaseRef(projectRoot, snapshot.head)
+  await restoreWorkspaceToBase(projectRoot, snapshot.head)
+
+  return { snapshot }
+}

package/src/types.ts

@@ -0,0 +1,48 @@
+export type VariantStatus = "draft" | "running" | "ready" | "selected" | "archived"
+
+export type ObjectiveStatus = "open" | "review" | "finalized"
+
+export interface VariantArtifact {
+  id: string
+  objectiveId: string
+  name: string
+  baseRef: string
+  patchFile: string
+  changedFiles: string[]
+  sessionId?: string
+  screenshots: string[]
+  notes?: string
+  status: VariantStatus
+  createdAt: string
+  updatedAt: string
+}
+
+export interface Objective {
+  id: string
+  name: string
+  baseRef: string
+  status: ObjectiveStatus
+  winnerVariantId?: string
+  activeVariantId?: string
+  variants: VariantArtifact[]
+  createdAt: string
+  updatedAt: string
+}
+
+export interface PreviewProfile {
+  id: string
+  name: string
+  selections: Record<string, string>
+  lastAppliedAt?: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface VariantStore {
+  schemaVersion: 2
+  projectRoot: string
+  baseRef: string
+  objectives: Objective[]
+  profiles: PreviewProfile[]
+  activeProfileId?: string
+}

package/vite/index.d.ts

@@ -0,0 +1,11 @@
+export interface VyntVitePluginOptions {
+  enabled?: boolean;
+  bridgeHost?: string;
+  bridgePort?: number;
+  prefix?: string;
+  projectRoot?: string;
+}
+
+export declare function vyntVitePlugin(
+  options?: VyntVitePluginOptions,
+): import("vite").Plugin;

package/vite/index.js

@@ -0,0 +1,140 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_PATH = resolve(__dirname, "..", "src", "cli.ts");
+
+function parsePortFromOutput(line) {
+  const match = line.match(/Bridge server listening on .*:(\d+)/);
+  if (!match) return null;
+  const port = Number(match[1]);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  return port;
+}
+
+function discoverProjectRoot(fromDirectory) {
+  let current = resolve(fromDirectory);
+
+  while (true) {
+    if (existsSync(join(current, ".vynt", "state.json"))) {
+      return current;
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return resolve(fromDirectory);
+    }
+    current = parent;
+  }
+}
+
+export function vyntVitePlugin(options = {}) {
+  const enabled = options.enabled ?? true;
+  const bridgeHost = options.bridgeHost ?? "127.0.0.1";
+  const bridgePort = options.bridgePort ?? 4173;
+  const prefix = options.prefix ?? "/__vynt";
+  const configuredProjectRoot = options.projectRoot;
+
+  let processRef = null;
+  let shuttingDown = false;
+
+  return {
+    name: "vynt-vite",
+    apply: "serve",
+
+    config(userConfig) {
+      if (!enabled) return undefined;
+
+      const target = `http://${bridgeHost}:${bridgePort}`;
+      const existingProxy = (userConfig.server && userConfig.server.proxy) || {};
+
+      return {
+        server: {
+          proxy: {
+            ...existingProxy,
+            [prefix]: {
+              target,
+              changeOrigin: false,
+              rewrite(path) {
+                const rewritten = path.slice(prefix.length);
+                return rewritten.length > 0 ? rewritten : "/";
+              },
+            },
+          },
+        },
+      };
+    },
+
+    configureServer(server) {
+      if (!enabled) return;
+
+      const start = () => {
+        if (processRef) return;
+
+        const bridgeCwd = configuredProjectRoot
+          ? resolve(server.config.root, configuredProjectRoot)
+          : discoverProjectRoot(server.config.root);
+
+        const child = spawn("bun", [CLI_PATH, "bridge", "serve", "--host", bridgeHost, "--port", String(bridgePort)], {
+          cwd: bridgeCwd,
+          env: process.env,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        processRef = child;
+
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+
+        child.stdout.on("data", (chunk) => {
+          const text = String(chunk);
+          for (const line of text.split("\n")) {
+            if (!line.trim()) continue;
+            const parsedPort = parsePortFromOutput(line);
+            if (parsedPort) {
+              server.config.logger.info(`[vynt] bridge running on ${bridgeHost}:${parsedPort} proxied at ${prefix}`);
+            } else {
+              server.config.logger.info(`[vynt] ${line}`);
+            }
+          }
+        });
+
+        child.stderr.on("data", (chunk) => {
+          const text = String(chunk).trim();
+          if (text.length > 0) {
+            server.config.logger.error(`[vynt] ${text}`);
+          }
+        });
+
+        child.on("error", (error) => {
+          server.config.logger.error(`[vynt] failed to start bridge: ${error instanceof Error ? error.message : String(error)}`);
+        });
+
+        child.on("exit", (code, signal) => {
+          const exitText = `bridge exited (code=${code ?? "null"} signal=${signal ?? "null"})`;
+          if (!shuttingDown) {
+            server.config.logger.warn(`[vynt] ${exitText}`);
+          }
+          processRef = null;
+        });
+      };
+
+      const stop = () => {
+        if (!processRef) return;
+        shuttingDown = true;
+        processRef.kill("SIGTERM");
+      };
+
+      start();
+      server.httpServer?.once("close", stop);
+
+      const onSigint = () => stop();
+      const onSigterm = () => stop();
+      process.once("SIGINT", onSigint);
+      process.once("SIGTERM", onSigterm);
+    },
+  };
+}