resulgit 1.0.0

package/resulgit.js

@@ -0,0 +1,2309 @@
+#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+const COLORS = { reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[34m', magenta: '\x1b[35m', cyan: '\x1b[36m' }
+function color(str, c) { return (COLORS[c] || '') + String(str) + COLORS.reset }
+
+function parseArgs(argv) {
+  const tokens = argv.slice(2)
+  const cmd = []
+  const opts = {}
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (t.startsWith('--')) {
+      const key = t.slice(2)
+      const val = tokens[i + 1] && !tokens[i + 1].startsWith('--') ? tokens[++i] : 'true'
+      opts[key] = val
+    } else if (cmd.length < 2) {
+      cmd.push(t)
+    }
+  }
+  return { cmd, opts }
+}
+
+function configPath() {
+  const dir = path.join(os.homedir(), '.resulgit')
+  const file = path.join(dir, 'config.json')
+  return { dir, file }
+}
+
+function loadConfig() {
+  const { dir, file } = configPath()
+  try {
+    const s = fs.readFileSync(file, 'utf8')
+    return JSON.parse(s)
+  } catch {
+    return { server: 'https://delightful-dango-ee4842.netlify.app', token: '', workspaceRoot: path.join(os.homedir(), 'resulgit-workspace') }
+  }
+}
+
+function saveConfig(update) {
+  const { dir, file } = configPath()
+  const cur = loadConfig()
+  const next = { ...cur, ...update }
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(file, JSON.stringify(next, null, 2))
+  return next
+}
+
+function getServer(opts, cfg) {
+  return opts.server || cfg.server || 'https://delightful-dango-ee4842.netlify.app'
+}
+
+function getToken(opts, cfg) {
+  return opts.token || cfg.token || ''
+}
+
+async function request(method, url, body, token) {
+  const headers = { 'Content-Type': 'application/json' }
+  if (token) headers.Authorization = `Bearer ${token}`
+  const res = await fetch(url, { method, headers, body: body ? JSON.stringify(body) : undefined })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`${res.status} ${res.statusText} ${text}`)
+  }
+  const ct = res.headers.get('content-type') || ''
+  if (ct.includes('application/json')) return res.json()
+  return res.text()
+}
+
+function print(obj, json) {
+  if (json) {
+    process.stdout.write(JSON.stringify(obj, null, 2) + '\n')
+    return
+  }
+  if (Array.isArray(obj)) {
+    for (const o of obj) process.stdout.write(`${o.id || ''}\t${o.name || ''}\n`)
+    return
+  }
+  if (typeof obj === 'string') {
+    process.stdout.write(obj + '\n')
+    return
+  }
+  process.stdout.write(Object.entries(obj).map(([k, v]) => `${k}: ${typeof v === 'object' ? JSON.stringify(v) : v}`).join('\n') + '\n')
+}
+
+async function cmdAuth(sub, opts) {
+  if (sub === 'set-token') {
+    const token = opts.token || ''
+    if (!token) throw new Error('Missing --token')
+    const cfg = saveConfig({ token })
+    print({ token: cfg.token }, opts.json === 'true')
+    return
+  }
+  if (sub === 'set-server') {
+    const server = opts.server || ''
+    if (!server) throw new Error('Missing --server')
+    const cfg = saveConfig({ server })
+    print({ server: cfg.server }, opts.json === 'true')
+    return
+  }
+  if (sub === 'login') {
+    const server = opts.server || loadConfig().server
+    const email = opts.email
+    const password = opts.password
+    if (!email || !password) throw new Error('Missing --email and --password')
+    const url = new URL('/api/auth/login', server).toString()
+    const res = await request('POST', url, { email, password }, '')
+    const token = res.token || ''
+    if (token) saveConfig({ token })
+    print(res, opts.json === 'true')
+    return
+  }
+  if (sub === 'register') {
+    const server = opts.server || loadConfig().server
+    const username = opts.username
+    const email = opts.email
+    const password = opts.password
+    const displayName = opts.displayName || username
+    if (!username || !email || !password) throw new Error('Missing --username --email --password')
+    const url = new URL('/api/auth/register', server).toString()
+    const res = await request('POST', url, { username, email, password, displayName }, '')
+    const token = res.token || ''
+    if (token) saveConfig({ token })
+    print(res, opts.json === 'true')
+    return
+  }
+  throw new Error('Unknown auth subcommand')
+}
+
+async function cmdRepo(sub, opts, cfg) {
+  const server = getServer(opts, cfg)
+  const token = getToken(opts, cfg)
+  if (sub === 'list') {
+    const url = new URL('/api/repositories', server).toString()
+    const data = await request('GET', url, null, token)
+    print(data, opts.json === 'true')
+    await tuiSelectRepo(data || [], cfg, opts)
+    return
+  }
+  if (sub === 'create') {
+    const body = {
+      name: opts.name || '',
+      description: opts.description || '',
+      visibility: opts.visibility || 'private',
+      initializeWithReadme: opts.init === 'true'
+    }
+    if (!body.name) throw new Error('Missing --name')
+    const url = new URL('/api/repositories', server).toString()
+    const data = await request('POST', url, body, token)
+    print(data, opts.json === 'true')
+    try {
+      const repoId = String(data.id || '')
+      const branch = String(data.defaultBranch || 'main')
+      if (repoId) { await cmdClone({ repo: repoId, branch, dest: opts.dest }, cfg) }
+    } catch {}
+    return
+  }
+  if (sub === 'log') {
+    const repo = opts.repo
+    const branch = opts.branch
+    if (!repo) throw new Error('Missing --repo')
+    const u = new URL(`/api/repositories/${repo}/commits`, server)
+    if (branch) u.searchParams.set('branch', branch)
+    const data = await request('GET', u.toString(), null, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  if (sub === 'head') {
+    const repo = opts.repo
+    const branchOpt = opts.branch
+    if (!repo) throw new Error('Missing --repo')
+    const info = await request('GET', new URL(`/api/repositories/${repo}/branches`, server).toString(), null, token)
+    let branch = branchOpt || info.defaultBranch || 'main'
+    const found = (info.branches || []).find(b => b.name === branch)
+    const commitId = found ? (found.commitId || '') : ''
+    const out = { branch, commitId }
+    print(opts.json === 'true' ? out : (commitId || ''), opts.json === 'true')
+    return
+  }
+  if (sub === 'select') {
+    const url = new URL('/api/repositories', server).toString()
+    const repos = await request('GET', url, null, token)
+    await tuiSelectRepo(repos || [], cfg, opts)
+    return
+  }
+  throw new Error('Unknown repo subcommand')
+}
+
+async function cmdClone(opts, cfg) {
+  const server = getServer(opts, cfg)
+  const token = getToken(opts, cfg)
+  const repo = opts.repo
+  const branch = opts.branch
+  let dest = opts.dest
+  if (!repo || !branch) throw new Error('Missing --repo and --branch')
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  if (!dest) {
+    try {
+      const infoUrl = new URL(`/api/repositories/${repo}`, server)
+      const infoRes = await fetch(infoUrl.toString(), { headers })
+      if (infoRes.ok) {
+        const info = await infoRes.json()
+        const name = info.name || String(repo)
+        dest = name
+      } else {
+        dest = String(repo)
+      }
+    } catch {
+      dest = String(repo)
+    }
+  }
+  dest = path.resolve(dest)
+  const url = new URL(`/api/repositories/${repo}/snapshot`, server)
+  url.searchParams.set('branch', branch)
+  const res = await fetch(url.toString(), { headers })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`Snapshot fetch failed: ${res.status} ${res.statusText} - ${text}`)
+  }
+  const data = await res.json()
+  const files = data.files || {}
+  const root = dest
+  for (const [p, content] of Object.entries(files)) {
+    const fullPath = path.join(root, p)
+    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true })
+    await fs.promises.writeFile(fullPath, content, 'utf8')
+  }
+  const metaDir = path.join(root, '.vcs-next')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  const meta = { repoId: repo, branch, commitId: data.commitId || '', server, token: token || '' }
+  await fs.promises.writeFile(path.join(metaDir, 'remote.json'), JSON.stringify(meta, null, 2))
+  const gitDir = path.join(root, '.git')
+  const refsHeadsDir = path.join(gitDir, 'refs', 'heads')
+  await fs.promises.mkdir(refsHeadsDir, { recursive: true })
+  const headContent = `ref: refs/heads/${branch}\n`
+  await fs.promises.writeFile(path.join(gitDir, 'HEAD'), headContent, 'utf8')
+  const commitId = data.commitId || ''
+  await fs.promises.writeFile(path.join(refsHeadsDir, branch), commitId, 'utf8')
+  const gitConfig = [
+    '[core]',
+    '\trepositoryformatversion = 0',
+    '\tfilemode = true',
+    '\tbare = false',
+    '\tlogallrefupdates = true',
+    '',
+    '[vcs-next]',
+    `\tserver = ${server}`,
+    `\trepoId = ${repo}`,
+    `\tbranch = ${branch}`,
+    `\ttoken = ${token || ''}`
+  ].join('\n')
+  await fs.promises.writeFile(path.join(gitDir, 'config'), gitConfig, 'utf8')
+  await fs.promises.writeFile(path.join(gitDir, 'vcs-next.json'), JSON.stringify({ ...meta }, null, 2))
+  try {
+    const branchesUrl = new URL(`/api/repositories/${repo}/branches`, server)
+    const branchesRes = await fetch(branchesUrl.toString(), { headers })
+    if (branchesRes.ok) {
+      const branchesData = await branchesRes.json()
+      const branches = Array.isArray(branchesData.branches) ? branchesData.branches : []
+      const allRefs = {}
+      for (const b of branches) {
+        const name = b.name || ''
+        const id = b.commitId || ''
+        if (!name) continue
+        allRefs[name] = id
+        await fs.promises.writeFile(path.join(refsHeadsDir, name), id, 'utf8')
+      }
+      await fs.promises.writeFile(path.join(gitDir, 'vcs-next-refs.json'), JSON.stringify(allRefs, null, 2))
+    }
+  } catch {}
+  try {
+    const commitsUrl = new URL(`/api/repositories/${repo}/commits`, server)
+    commitsUrl.searchParams.set('branch', branch)
+    const commitsRes = await fetch(commitsUrl.toString(), { headers })
+    if (commitsRes.ok) {
+      const commitsList = await commitsRes.json()
+      await fs.promises.writeFile(path.join(gitDir, 'vcs-next-commits.json'), JSON.stringify(commitsList || [], null, 2))
+    }
+  } catch {}
+  print('Clone complete', opts.json === 'true')
+}
+
+function readRemoteMeta(dir) {
+  const abs = path.resolve(dir)
+  const tryFiles = (d) => [
+    path.join(d, '.vcs-next', 'remote.json'),
+    path.join(d, '.git', 'vcs-next.json')
+  ]
+  let cur = abs
+  while (true) {
+    for (const fp of tryFiles(cur)) {
+      try {
+        const s = fs.readFileSync(fp, 'utf8')
+        const meta = JSON.parse(s)
+        if (meta.repoId && meta.branch) return meta
+      } catch {}
+    }
+    const parent = path.dirname(cur)
+    if (parent === cur) break
+    cur = parent
+  }
+  const hint = `${abs}`
+  const err = new Error(`Not a cloned repository: ${hint}. Use --dir <path> or run inside a cloned repo.`)
+  throw err
+}
+
+function hashContent(buf) {
+  return crypto.createHash('sha1').update(buf).digest('hex')
+}
+
+async function collectLocal(dir) {
+  const out = {}
+  const base = path.resolve(dir)
+  async function walk(cur, rel) {
+    const entries = await fs.promises.readdir(cur, { withFileTypes: true })
+    for (const e of entries) {
+      if (e.name === '.git' || e.name === '.vcs-next') continue
+      const abs = path.join(cur, e.name)
+      const rp = rel ? rel + '/' + e.name : e.name
+      if (e.isDirectory()) {
+        await walk(abs, rp)
+      } else if (e.isFile()) {
+        const buf = await fs.promises.readFile(abs)
+        out[rp] = { content: buf.toString('utf8'), id: hashContent(buf) }
+      }
+    }
+  }
+  await walk(base, '')
+  return out
+}
+
+async function fetchRemoteFilesMap(server, repo, branch, token) {
+  const u = new URL(`/api/repositories/${repo}/files/all`, server)
+  u.searchParams.set('branchId', branch)
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  const res = await fetch(u.toString(), { headers })
+  if (res.ok) {
+    const data = await res.json()
+    const map = {}
+    for (const it of data.entries || []) map[it.path] = it.id
+    return { map, headCommitId: data.commitId }
+  }
+  const su = new URL(`/api/repositories/${repo}/snapshot`, server)
+  su.searchParams.set('branch', branch)
+  const sres = await fetch(su.toString(), { headers })
+  if (sres.ok) {
+    const data = await sres.json()
+    const files = data.files || {}
+    const map = {}
+    for (const [p, content] of Object.entries(files)) {
+      const id = hashContent(Buffer.from(String(content)))
+      map[p] = id
+    }
+    return { map, headCommitId: data.commitId }
+  }
+  const rtext = await res.text().catch(() => '')
+  const stext = await sres.text().catch(() => '')
+  throw new Error(`remote fetch failed: ${res.status} ${res.statusText} ${rtext}; snapshot failed: ${sres.status} ${sres.statusText} ${stext}`)
+}
+
+async function cmdStatus(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const local = await collectLocal(dir)
+  const remote = await fetchRemoteFilesMap(server, meta.repoId, meta.branch, token)
+  const added = []
+  const modified = []
+  const deleted = []
+  const remotePaths = new Set(Object.keys(remote.map))
+  const localPaths = new Set(Object.keys(local))
+  for (const p of localPaths) {
+    if (!remotePaths.has(p)) added.push(p)
+    else if (remote.map[p] !== local[p].id) modified.push(p)
+  }
+  for (const p of remotePaths) {
+    if (!localPaths.has(p)) deleted.push(p)
+  }
+  const out = { branch: meta.branch, head: remote.headCommitId, added, modified, deleted }
+  print(out, opts.json === 'true')
+}
+
+async function cmdRestore(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const filePath = opts.path
+  if (!filePath) throw new Error('Missing --path')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  
+  const sourceCommit = opts.source || 'HEAD'
+  let sourceSnap
+  if (sourceCommit === 'HEAD') {
+    sourceSnap = await fetchRemoteSnapshot(server, meta.repoId, meta.branch, token)
+  } else {
+    sourceSnap = await fetchSnapshotByCommit(server, meta.repoId, sourceCommit, token)
+  }
+  
+  const sourceContent = sourceSnap.files[filePath]
+  if (sourceContent === undefined) {
+    // File doesn't exist in source - delete it
+    const fp = path.join(dir, filePath)
+    try {
+      await fs.promises.unlink(fp)
+      if (opts.json === 'true') {
+        print({ restored: filePath, action: 'deleted' }, true)
+      } else {
+        process.stdout.write(color(`Restored ${filePath} (deleted)\n`, 'green'))
+      }
+    } catch {
+      if (opts.json !== 'true') process.stdout.write(`File ${filePath} doesn't exist\n`)
+      else print({ restored: filePath, action: 'noop' }, true)
+    }
+  } else {
+    // Restore file from source
+    const fp = path.join(dir, filePath)
+    await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+    await fs.promises.writeFile(fp, String(sourceContent), 'utf8')
+    if (opts.json === 'true') {
+      print({ restored: filePath, from: sourceCommit }, true)
+    } else {
+      process.stdout.write(color(`Restored ${filePath} from ${sourceCommit}\n`, 'green'))
+    }
+  }
+}
+
+async function cmdDiff(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  
+  const filePath = opts.path
+  const commitId = opts.commit
+  
+  if (commitId) {
+    // Show diff for specific commit
+    const commit = await fetchCommitMeta(server, meta.repoId, commitId, token)
+    const parentId = (Array.isArray(commit.parents) && commit.parents[0]) || ''
+    const commitSnap = await fetchSnapshotByCommit(server, meta.repoId, commitId, token)
+    const parentSnap = parentId ? await fetchSnapshotByCommit(server, meta.repoId, parentId, token) : { files: {}, commitId: '' }
+    
+    const files = filePath ? [filePath] : Object.keys(new Set([...Object.keys(parentSnap.files), ...Object.keys(commitSnap.files)]))
+    for (const p of files) {
+      const oldContent = parentSnap.files[p] !== undefined ? String(parentSnap.files[p]) : null
+      const newContent = commitSnap.files[p] !== undefined ? String(commitSnap.files[p]) : null
+      if (oldContent !== newContent) {
+        if (opts.json === 'true') {
+          print({ path: p, old: oldContent, new: newContent }, true)
+        } else {
+          process.stdout.write(color(`diff --git a/${p} b/${p}\n`, 'dim'))
+          if (oldContent === null) {
+            process.stdout.write(color(`+++ b/${p}\n`, 'green'))
+            process.stdout.write(color(`+${newContent}\n`, 'green'))
+          } else if (newContent === null) {
+            process.stdout.write(color(`--- a/${p}\n`, 'red'))
+            process.stdout.write(color(`-${oldContent}\n`, 'red'))
+          } else {
+            const oldLines = oldContent.split(/\r?\n/)
+            const newLines = newContent.split(/\r?\n/)
+            const maxLen = Math.max(oldLines.length, newLines.length)
+            for (let i = 0; i < maxLen; i++) {
+              const oldLine = oldLines[i]
+              const newLine = newLines[i]
+              if (oldLine !== newLine) {
+                if (oldLine !== undefined) process.stdout.write(color(`-${oldLine}\n`, 'red'))
+                if (newLine !== undefined) process.stdout.write(color(`+${newLine}\n`, 'green'))
+              } else if (oldLine !== undefined) {
+                process.stdout.write(` ${oldLine}\n`)
+              }
+            }
+          }
+        }
+      }
+    }
+    return
+  }
+  
+  // Show diff for working directory
+  const remoteSnap = await fetchRemoteSnapshot(server, meta.repoId, meta.branch, token)
+  const local = await collectLocal(dir)
+  const files = filePath ? [filePath] : Object.keys(new Set([...Object.keys(remoteSnap.files), ...Object.keys(local)]))
+  
+  for (const p of files) {
+    const remoteContent = remoteSnap.files[p] !== undefined ? String(remoteSnap.files[p]) : null
+    const localContent = local[p]?.content || null
+    const remoteId = remoteSnap.files[p] !== undefined ? hashContent(Buffer.from(String(remoteSnap.files[p]))) : null
+    const localId = local[p]?.id
+    
+    if (remoteId !== localId) {
+      if (opts.json === 'true') {
+        print({ path: p, remote: remoteContent, local: localContent }, true)
+      } else {
+        process.stdout.write(color(`diff --git a/${p} b/${p}\n`, 'dim'))
+        if (localContent === null) {
+          process.stdout.write(color(`--- a/${p}\n`, 'red'))
+          process.stdout.write(color(`-${remoteContent || ''}\n`, 'red'))
+        } else if (remoteContent === null) {
+          process.stdout.write(color(`+++ b/${p}\n`, 'green'))
+          process.stdout.write(color(`+${localContent}\n`, 'green'))
+        } else {
+          const remoteLines = String(remoteContent).split(/\r?\n/)
+          const localLines = String(localContent).split(/\r?\n/)
+          const maxLen = Math.max(remoteLines.length, localLines.length)
+          for (let i = 0; i < maxLen; i++) {
+            const remoteLine = remoteLines[i]
+            const localLine = localLines[i]
+            if (remoteLine !== localLine) {
+              if (remoteLine !== undefined) process.stdout.write(color(`-${remoteLine}\n`, 'red'))
+              if (localLine !== undefined) process.stdout.write(color(`+${localLine}\n`, 'green'))
+            } else if (remoteLine !== undefined) {
+              process.stdout.write(` ${remoteLine}\n`)
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+async function cmdRm(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const pathArg = opts.path
+  if (!pathArg) throw new Error('Missing --path')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const u = new URL(`/api/repositories/${meta.repoId}/files`, server)
+  u.searchParams.set('branch', meta.branch)
+  u.searchParams.set('path', pathArg)
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  const res = await fetch(u.toString(), { method: 'DELETE', headers })
+  if (!res.ok) {
+    const t = await res.text()
+    throw new Error(t || 'delete failed')
+  }
+  const data = await res.json()
+  print(data, opts.json === 'true')
+}
+
+async function cmdCommit(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const message = opts.message || ''
+  if (!message) throw new Error('Missing --message')
+  
+  // Check for unresolved conflicts
+  const unresolvedConflicts = await checkForUnresolvedConflicts(dir)
+  if (unresolvedConflicts.length > 0) {
+    if (opts.json === 'true') {
+      print({ error: 'Cannot commit with unresolved conflicts', conflicts: unresolvedConflicts }, true)
+    } else {
+      process.stderr.write(color('Error: Cannot commit with unresolved conflicts\n', 'red'))
+      process.stderr.write(color('Conflicts in files:\n', 'yellow'))
+      for (const p of unresolvedConflicts) {
+        process.stderr.write(color(`  ${p}\n`, 'red'))
+      }
+      process.stderr.write(color('\nResolve conflicts manually before committing.\n', 'yellow'))
+    }
+    return
+  }
+  
+  const metaDir = path.join(dir, '.vcs-next')
+  const localPath = path.join(metaDir, 'local.json')
+  let localMeta = { baseCommitId: '', baseFiles: {}, pendingCommit: null }
+  try {
+    const s = await fs.promises.readFile(localPath, 'utf8')
+    localMeta = JSON.parse(s)
+  } catch {}
+  const local = await collectLocal(dir)
+  const files = {}
+  for (const [p, v] of Object.entries(local)) files[p] = v.content
+  localMeta.pendingCommit = { message, files, createdAt: Date.now() }
+  // Clear conflicts if they were resolved
+  if (localMeta.conflicts) {
+    delete localMeta.conflicts
+  }
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+  print({ pendingCommit: message }, opts.json === 'true')
+}
+
+async function pullToDir(repo, branch, dir, server, token) {
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  const url = new URL(`/api/repositories/${repo}/snapshot`, server)
+  url.searchParams.set('branch', branch)
+  const res = await fetch(url.toString(), { headers })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`Snapshot fetch failed: ${res.status} ${res.statusText} - ${text}`)
+  }
+  const data = await res.json()
+  const files = data.files || {}
+  const root = path.resolve(dir)
+  for (const [p, content] of Object.entries(files)) {
+    const fullPath = path.join(root, p)
+    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true })
+    await fs.promises.writeFile(fullPath, content, 'utf8')
+  }
+  const keep = new Set(Object.keys(files))
+  const localMap = await collectLocal(root)
+  for (const rel of Object.keys(localMap)) {
+    if (!keep.has(rel)) {
+      const fp = path.join(root, rel)
+      try { await fs.promises.unlink(fp) } catch {}
+    }
+  }
+  const pruneEmptyDirs = async (start) => {
+    const entries = await fs.promises.readdir(start).catch(() => [])
+    for (const name of entries) {
+      if (name === '.git' || name === '.vcs-next') continue
+      const p = path.join(start, name)
+      const st = await fs.promises.stat(p).catch(() => null)
+      if (!st) continue
+      if (st.isDirectory()) {
+        await pruneEmptyDirs(p)
+        const left = await fs.promises.readdir(p).catch(() => [])
+        if (left.length === 0) { try { await fs.promises.rmdir(p) } catch {} }
+      }
+    }
+  }
+  await pruneEmptyDirs(root)
+  const metaDir = path.join(root, '.vcs-next')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  const meta = { repoId: repo, branch, commitId: data.commitId || '', server, token: token || '' }
+  await fs.promises.writeFile(path.join(metaDir, 'remote.json'), JSON.stringify(meta, null, 2))
+  const gitDir = path.join(root, '.git')
+  const refsHeadsDir = path.join(gitDir, 'refs', 'heads')
+  await fs.promises.mkdir(refsHeadsDir, { recursive: true })
+  const headContent = `ref: refs/heads/${branch}\n`
+  await fs.promises.writeFile(path.join(gitDir, 'HEAD'), headContent, 'utf8')
+  const commitId = data.commitId || ''
+  await fs.promises.writeFile(path.join(refsHeadsDir, branch), commitId, 'utf8')
+  const localMeta = { baseCommitId: commitId, baseFiles: files, pendingCommit: null }
+  await fs.promises.writeFile(path.join(metaDir, 'local.json'), JSON.stringify(localMeta, null, 2))
+}
+
+async function cmdPull(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  await pullToDir(meta.repoId, meta.branch, dir, server, token)
+  print('Pull complete', opts.json === 'true')
+}
+
+async function fetchRemoteSnapshot(server, repo, branch, token) {
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  const url = new URL(`/api/repositories/${repo}/snapshot`, server)
+  if (branch) url.searchParams.set('branch', branch)
+  const res = await fetch(url.toString(), { headers })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(text || 'snapshot failed')
+  }
+  const data = await res.json()
+  return { files: data.files || {}, commitId: data.commitId || '' }
+}
+
+async function fetchSnapshotByCommit(server, repo, commitId, token) {
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  const url = new URL(`/api/repositories/${repo}/snapshot`, server)
+  url.searchParams.set('commitId', commitId)
+  const res = await fetch(url.toString(), { headers })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(text || 'snapshot failed')
+  }
+  const data = await res.json()
+  return { files: data.files || {}, commitId: data.commitId || '' }
+}
+
+async function fetchCommitMeta(server, repo, commitId, token) {
+  const headers = token ? { Authorization: `Bearer ${token}` } : {}
+  const url = new URL(`/api/repositories/${repo}/commits/${commitId}`, server)
+  const res = await fetch(url.toString(), { headers })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(text || 'commit meta failed')
+  }
+  const data = await res.json()
+  return data
+}
+
+function applyCherry(base, next, localContent) {
+  const b = base === undefined ? null : String(base)
+  const n = next === undefined ? null : String(next)
+  const l = localContent === undefined ? null : String(localContent)
+  const changedLocal = l !== b
+  const changedRemote = n !== b
+  if (changedLocal && changedRemote && l !== n) {
+    return { conflict: true }
+  }
+  if (changedLocal && !changedRemote) return { content: l }
+  if (!changedLocal && changedRemote) return { content: n }
+  return { content: b }
+}
+
+async function cmdCherryPick(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const commitId = opts.commit
+  if (!commitId) throw new Error('Missing --commit')
+  const branchesInfo = await request('GET', new URL(`/api/repositories/${meta.repoId}/branches`, server).toString(), null, token)
+  let targetBranch = opts.branch || ''
+  if (!targetBranch) {
+    let current = meta.branch
+    try {
+      const head = fs.readFileSync(path.join(dir, '.git', 'HEAD'), 'utf8')
+      const m = head.match(/refs\/heads\/(.+)/)
+      if (m) current = m[1]
+    } catch {}
+    targetBranch = await tuiSelectBranch(branchesInfo.branches || [], current)
+  }
+  const exists = (branchesInfo.branches || []).some((b) => b.name === targetBranch)
+  if (!exists) throw new Error(`Invalid branch: ${targetBranch}`)
+  
+  // Get the current state of the target branch (what we're cherry-picking onto)
+  const currentSnap = await fetchRemoteSnapshot(server, meta.repoId, targetBranch, token)
+  
+  // Get the commit being cherry-picked and its parent
+  const commit = await fetchCommitMeta(server, meta.repoId, commitId, token)
+  const parentId = (Array.isArray(commit.parents) && commit.parents[0]) || ''
+  const targetSnap = await fetchSnapshotByCommit(server, meta.repoId, commitId, token)
+  const baseSnap = parentId ? await fetchSnapshotByCommit(server, meta.repoId, parentId, token) : { files: {}, commitId: '' }
+  
+  // Pull the target branch to ensure we're working with the latest state
+  await pullToDir(meta.repoId, targetBranch, dir, server, token)
+  
+  // Re-collect local state after pull (now it matches the target branch)
+  const localAfterPull = await collectLocal(dir)
+  
+  // Update local metadata to reflect the pulled state
+  const metaDirInit = path.join(dir, '.vcs-next')
+  await fs.promises.mkdir(metaDirInit, { recursive: true })
+  const localPathInit = path.join(metaDirInit, 'local.json')
+  let localMetaInit = { baseCommitId: '', baseFiles: {}, pendingCommit: null }
+  try { const s = await fs.promises.readFile(localPathInit, 'utf8'); localMetaInit = JSON.parse(s) } catch {}
+  localMetaInit.baseCommitId = currentSnap.commitId
+  localMetaInit.baseFiles = currentSnap.files
+  await fs.promises.writeFile(localPathInit, JSON.stringify(localMetaInit, null, 2))
+  
+  // Apply cherry-pick: compare base (parent of commit) vs target (the commit) vs current (target branch)
+  const conflicts = []
+  const changes = []
+  const mergedFiles = {}
+  const allPaths = new Set([...Object.keys(baseSnap.files), ...Object.keys(targetSnap.files), ...Object.keys(currentSnap.files)])
+  
+  for (const p of allPaths) {
+    const b = baseSnap.files[p]  // base: parent of commit being cherry-picked
+    const n = targetSnap.files[p]  // next: the commit being cherry-picked
+    const c = currentSnap.files[p]  // current: current state of target branch (from remote)
+    
+    // For cherry-pick, we need to apply the changes from the commit onto the current branch
+    // The logic: if the commit changed something from its parent, apply that change to current
+    const baseContent = b !== undefined ? String(b) : null
+    const commitContent = n !== undefined ? String(n) : null
+    const currentContent = c !== undefined ? String(c) : null
+    
+    // Check if commit changed this file from its parent
+    const commitChanged = baseContent !== commitContent
+    
+    if (commitChanged) {
+      // The commit modified this file - we want to apply that change
+      // Conflict detection: 
+      // - If file was added in commit (base=null, commit=content) and current=null: NO CONFLICT (just add it)
+      // - If file was modified in commit (base=content1, commit=content2) and current=content1: NO CONFLICT (apply change)
+      // - If file was modified in commit (base=content1, commit=content2) and current=content3 (different): CONFLICT
+      // - If file was deleted in commit (base=content, commit=null) and current=content: NO CONFLICT (delete it)
+      // - If file was deleted in commit (base=content, commit=null) and current=content2 (different): CONFLICT
+      
+      const fileWasAdded = baseContent === null && commitContent !== null
+      const fileWasDeleted = baseContent !== null && commitContent === null
+      const fileWasModified = baseContent !== null && commitContent !== null && baseContent !== commitContent
+      
+      // Check for conflicts: current branch changed the file differently than the commit
+      const currentChangedFromBase = currentContent !== baseContent
+      const currentDiffersFromCommit = currentContent !== commitContent
+      
+      // Conflict detection:
+      // - If file was added in commit (base=null, commit=content) and current=null: NO CONFLICT (safe to add)
+      // - If file was added in commit (base=null, commit=content) and current=content2: CONFLICT (both added differently)
+      // - If file was modified in commit (base=content1, commit=content2) and current=content1: NO CONFLICT (apply change)
+      // - If file was modified in commit (base=content1, commit=content2) and current=content3: CONFLICT (both modified differently)
+      // - If file was deleted in commit (base=content, commit=null) and current=content: NO CONFLICT (delete it)
+      // - If file was deleted in commit (base=content, commit=null) and current=content2: CONFLICT (current modified it)
+      
+      // Conflict if:
+      // 1. Current branch changed the file from base (current !== base)
+      // 2. AND current differs from what commit wants (current !== commit)
+      // 3. AND it's not the case where file was added in commit AND doesn't exist in current (safe case)
+      // 
+      // Special case: If file was added in commit (base=null, commit=content) and doesn't exist in current (current=null),
+      // this is always safe - no conflict. The file is simply being added.
+      const safeAddCase = fileWasAdded && currentContent === null
+      const fileExistsInCurrent = c !== undefined  // Check if file actually exists in current branch
+      
+      // Only conflict if file exists in current AND was changed differently
+      if (fileExistsInCurrent && currentChangedFromBase && currentDiffersFromCommit && !safeAddCase) {
+        // Conflict: both changed the file differently
+        const line = firstDiffLine(currentContent || '', commitContent || '')
+        conflicts.push({ path: p, line, current: currentContent, incoming: commitContent })
+        // Don't set mergedFiles - will write conflict markers
+      } else {
+        // No conflict: apply the commit's version
+        if (commitContent !== null) {
+          mergedFiles[p] = commitContent
+          // Apply change if file is new or content differs
+          if (currentContent === null || currentContent !== commitContent) {
+            changes.push({ type: 'write', path: p, content: commitContent })
+          }
+        } else {
+          // File was deleted in the commit
+          if (currentContent !== null) {
+            changes.push({ type: 'delete', path: p })
+            // Don't add to mergedFiles (file is deleted)
+          }
+        }
+      }
+    } else {
+      // Commit didn't change this file - keep current state
+      if (currentContent !== null) {
+        mergedFiles[p] = currentContent
+      }
+    }
+  }
+  
+  if (conflicts.length > 0) {
+    // Write conflict markers to files
+    for (const conflict of conflicts) {
+      const fp = path.join(dir, conflict.path)
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      const conflictContent = writeConflictMarkers(
+        conflict.current,
+        conflict.incoming,
+        meta.branch,
+        `cherry-pick-${commitId.slice(0,7)}`
+      )
+      await fs.promises.writeFile(fp, conflictContent, 'utf8')
+    }
+    
+    // Store conflict state in metadata
+    const metaDir = path.join(dir, '.vcs-next')
+    await fs.promises.mkdir(metaDir, { recursive: true })
+    const localPath = path.join(metaDir, 'local.json')
+    let localMeta = { baseCommitId: currentSnap.commitId, baseFiles: currentSnap.files, pendingCommit: null, conflicts: conflicts.map(c => c.path) }
+    try {
+      const s = await fs.promises.readFile(localPath, 'utf8')
+      localMeta = { ...JSON.parse(s), conflicts: conflicts.map(c => c.path) }
+    } catch {}
+    await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+    
+    if (opts.json === 'true') {
+      print({ conflicts: conflicts.map(c => ({ path: c.path, line: c.line })), message: commit.message || '' }, true)
+    } else {
+      process.stdout.write(color(`\nCherry-pick conflict detected!\n`, 'red'))
+      process.stdout.write(color(`Conflicts in ${conflicts.length} file(s):\n`, 'yellow'))
+      for (const c of conflicts) {
+        process.stdout.write(color(`  ${c.path}:${c.line}\n`, 'red'))
+      }
+      process.stdout.write(color(`\nResolve conflicts manually, then commit and push.\n`, 'yellow'))
+      process.stdout.write(color(`Files with conflicts have been marked with conflict markers:\n`, 'dim'))
+      process.stdout.write(color(`  <<<<<<< ${meta.branch}\n`, 'dim'))
+      process.stdout.write(color(`  =======\n`, 'dim'))
+      process.stdout.write(color(`  >>>>>>> cherry-pick-${commitId.slice(0,7)}\n`, 'dim'))
+    }
+    return
+  }
+  
+  // Apply the changes to the filesystem
+  for (const ch of changes) {
+    const fp = path.join(dir, ch.path)
+    if (ch.type === 'delete') {
+      try { await fs.promises.unlink(fp) } catch {}
+    } else if (ch.type === 'write') {
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      await fs.promises.writeFile(fp, ch.content, 'utf8')
+    }
+  }
+  
+  // Update local metadata with the pending commit
+  const metaDir = path.join(dir, '.vcs-next')
+  const localPath = path.join(metaDir, 'local.json')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  let localMeta = { baseCommitId: currentSnap.commitId, baseFiles: currentSnap.files, pendingCommit: null }
+  try {
+    const s = await fs.promises.readFile(localPath, 'utf8')
+    localMeta = JSON.parse(s)
+  } catch {}
+  
+  const cherryMsg = opts.message || `cherry-pick ${commitId.slice(0,7)}: ${commit.message || ''}`
+  
+  // Collect final state after applying changes
+  const finalLocal = await collectLocal(dir)
+  const finalFiles = {}
+  for (const [p, v] of Object.entries(finalLocal)) {
+    finalFiles[p] = v.content
+  }
+  
+  // Set pending commit with the actual files
+  localMeta.pendingCommit = { message: cherryMsg, files: finalFiles, createdAt: Date.now() }
+  await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+  
+  // Ensure remote.json has the correct target branch before pushing
+  const remoteMetaPath = path.join(metaDir, 'remote.json')
+  let remoteMeta = { repoId: meta.repoId, branch: targetBranch, commitId: currentSnap.commitId, server, token: token || '' }
+  try {
+    const s = await fs.promises.readFile(remoteMetaPath, 'utf8')
+    remoteMeta = { ...JSON.parse(s), branch: targetBranch }
+  } catch {}
+  await fs.promises.writeFile(remoteMetaPath, JSON.stringify(remoteMeta, null, 2))
+  
+  // Also update .git metadata
+  const gitDir = path.join(dir, '.git')
+  const gitMetaPath = path.join(gitDir, 'vcs-next.json')
+  await fs.promises.mkdir(gitDir, { recursive: true })
+  await fs.promises.writeFile(gitMetaPath, JSON.stringify(remoteMeta, null, 2))
+  await fs.promises.writeFile(path.join(gitDir, 'HEAD'), `ref: refs/heads/${targetBranch}\n`, 'utf8')
+  
+  if (opts.json === 'true') {
+    print({ commit: commitId, branch: targetBranch, status: 'applied', changes: changes.length }, true)
+  } else {
+    process.stdout.write(color(`Cherry-pick ${commitId.slice(0,7)} → ${targetBranch}: applied (${changes.length} changes)\n`, 'green'))
+  }
+  
+  if (opts.noPush !== 'true') {
+    await cmdPush({ dir, json: opts.json, message: cherryMsg })
+  }
+}
+
+function firstDiffLine(a, b) {
+  const la = String(a).split(/\r?\n/)
+  const lb = String(b).split(/\r?\n/)
+  const n = Math.max(la.length, lb.length)
+  for (let i = 0; i < n; i++) {
+    const va = la[i] || ''
+    const vb = lb[i] || ''
+    if (va !== vb) return i + 1
+  }
+  return 0
+}
+
+function writeConflictMarkers(currentContent, incomingContent, currentLabel, incomingLabel) {
+  const current = String(currentContent || '')
+  const incoming = String(incomingContent || '')
+  const currentLines = current.split(/\r?\n/)
+  const incomingLines = incoming.split(/\r?\n/)
+  
+  // Simple conflict marker format
+  const markers = [
+    `<<<<<<< ${currentLabel || 'HEAD'}`,
+    ...currentLines,
+    '=======',
+    ...incomingLines,
+    `>>>>>>> ${incomingLabel || 'incoming'}`
+  ]
+  
+  return markers.join('\n')
+}
+
+function hasConflictMarkers(content) {
+  const text = String(content)
+  return text.includes('<<<<<<<') && text.includes('=======') && text.includes('>>>>>>>')
+}
+
+async function checkForUnresolvedConflicts(dir) {
+  const local = await collectLocal(dir)
+  const conflicts = []
+  for (const [p, v] of Object.entries(local)) {
+    if (hasConflictMarkers(v.content)) {
+      conflicts.push(p)
+    }
+  }
+  return conflicts
+}
+
+async function cmdPush(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const remoteMeta = readRemoteMeta(dir)
+  const metaDir = path.join(dir, '.vcs-next')
+  const localPath = path.join(metaDir, 'local.json')
+  let localMeta = { baseCommitId: '', baseFiles: {}, pendingCommit: null }
+  try {
+    const s = await fs.promises.readFile(localPath, 'utf8')
+    localMeta = JSON.parse(s)
+  } catch {}
+  
+  // Check for unresolved conflicts in files
+  const unresolvedConflicts = await checkForUnresolvedConflicts(dir)
+  if (unresolvedConflicts.length > 0) {
+    if (opts.json === 'true') {
+      print({ error: 'Unresolved conflicts', conflicts: unresolvedConflicts }, true)
+    } else {
+      process.stderr.write(color('Error: Cannot push with unresolved conflicts\n', 'red'))
+      process.stderr.write(color('Conflicts in files:\n', 'yellow'))
+      for (const p of unresolvedConflicts) {
+        process.stderr.write(color(`  ${p}\n`, 'red'))
+      }
+      process.stderr.write(color('\nResolve conflicts manually, then try pushing again.\n', 'yellow'))
+    }
+    return
+  }
+  
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || remoteMeta.server
+  const token = getToken(opts, cfg) || remoteMeta.token
+  const remote = await fetchRemoteSnapshot(server, remoteMeta.repoId, remoteMeta.branch, token)
+  const base = localMeta.baseFiles || {}
+  const local = await collectLocal(dir)
+  const conflicts = []
+  const merged = {}
+  const paths = new Set([...Object.keys(base), ...Object.keys(remote.files), ...Object.keys(local).map(k => k)])
+  for (const p of paths) {
+    const b = p in base ? base[p] : null
+    const r = p in remote.files ? remote.files[p] : null
+    const l = p in local ? local[p].content : null
+    const changedLocal = String(l) !== String(b)
+    const changedRemote = String(r) !== String(b)
+    if (changedLocal && changedRemote && String(l) !== String(r)) {
+      const line = firstDiffLine(l || '', r || '')
+      conflicts.push({ path: p, line })
+    } else if (changedLocal && !changedRemote) {
+      if (l !== null) merged[p] = l
+    } else if (!changedLocal && changedRemote) {
+      if (r !== null) merged[p] = r
+    } else {
+      if (b !== null) merged[p] = b
+    }
+  }
+  if (conflicts.length > 0) {
+    if (opts.json === 'true') {
+      print({ conflicts }, true)
+    } else {
+      process.stderr.write(color('Error: Cannot push with conflicts\n', 'red'))
+      process.stderr.write(color('Conflicts detected:\n', 'yellow'))
+      for (const c of conflicts) {
+        process.stderr.write(color(`  ${c.path}:${c.line}\n`, 'red'))
+      }
+    }
+    return
+  }
+  const body = { message: localMeta.pendingCommit?.message || (opts.message || 'Push'), files: merged, branchName: remoteMeta.branch }
+  const url = new URL(`/api/repositories/${remoteMeta.repoId}/commits`, server).toString()
+  const data = await request('POST', url, body, token)
+  localMeta.baseCommitId = data.id || remote.commitId || ''
+  localMeta.baseFiles = merged
+  localMeta.pendingCommit = null
+  await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+  print({ pushed: localMeta.baseCommitId }, opts.json === 'true')
+}
+
+async function cmdMerge(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const sourceBranch = opts.branch || ''
+  if (!sourceBranch) throw new Error('Missing --branch')
+  
+  // Get current branch state
+  const currentSnap = await fetchRemoteSnapshot(server, meta.repoId, meta.branch, token)
+  
+  // Get source branch state
+  const sourceSnap = await fetchRemoteSnapshot(server, meta.repoId, sourceBranch, token)
+  
+  // Find common ancestor (merge base)
+  // For simplicity, we'll use the current branch's base commit as the merge base
+  // In a full implementation, we'd find the actual common ancestor
+  const branchesInfo = await request('GET', new URL(`/api/repositories/${meta.repoId}/branches`, server).toString(), null, token)
+  const currentBranchInfo = (branchesInfo.branches || []).find(b => b.name === meta.branch)
+  const sourceBranchInfo = (branchesInfo.branches || []).find(b => b.name === sourceBranch)
+  if (!currentBranchInfo || !sourceBranchInfo) throw new Error('Branch not found')
+  
+  // Get base commit (for now, use current branch's commit as base)
+  // In real Git, we'd find the merge base commit
+  const baseSnap = await fetchRemoteSnapshot(server, meta.repoId, meta.branch, token)
+  
+  // Pull current branch to ensure we're up to date
+  await pullToDir(meta.repoId, meta.branch, dir, server, token)
+  const localAfterPull = await collectLocal(dir)
+  
+  // Three-way merge: base, current (target), source
+  const conflicts = []
+  const changes = []
+  const mergedFiles = {}
+  const allPaths = new Set([...Object.keys(baseSnap.files), ...Object.keys(currentSnap.files), ...Object.keys(sourceSnap.files)])
+  
+  for (const p of allPaths) {
+    const base = baseSnap.files[p] !== undefined ? String(baseSnap.files[p]) : null
+    const current = currentSnap.files[p] !== undefined ? String(currentSnap.files[p]) : null
+    const source = sourceSnap.files[p] !== undefined ? String(sourceSnap.files[p]) : null
+    
+    const currentChanged = current !== base
+    const sourceChanged = source !== base
+    
+    if (currentChanged && sourceChanged && current !== source) {
+      // Conflict: both branches changed the file differently
+      const line = firstDiffLine(current || '', source || '')
+      conflicts.push({ path: p, line, current, incoming: source })
+      // Don't set mergedFiles - will write conflict markers
+    } else if (sourceChanged && !currentChanged) {
+      // Source changed, current didn't - take source
+      if (source !== null) {
+        mergedFiles[p] = source
+        const localContent = localAfterPull[p]?.content || null
+        if (localContent !== source) {
+          changes.push({ type: 'write', path: p, content: source })
+        }
+      } else {
+        // Source deleted the file
+        if (current !== null) {
+          changes.push({ type: 'delete', path: p })
+        }
+      }
+    } else if (currentChanged && !sourceChanged) {
+      // Current changed, source didn't - keep current
+      if (current !== null) {
+        mergedFiles[p] = current
+      }
+    } else {
+      // Neither changed or both same - keep current/base
+      if (current !== null) {
+        mergedFiles[p] = current
+      } else if (base !== null) {
+        mergedFiles[p] = base
+      }
+    }
+  }
+  
+  if (conflicts.length > 0) {
+    // Write conflict markers to files
+    for (const conflict of conflicts) {
+      const fp = path.join(dir, conflict.path)
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      const conflictContent = writeConflictMarkers(
+        conflict.current,
+        conflict.incoming,
+        meta.branch,
+        sourceBranch
+      )
+      await fs.promises.writeFile(fp, conflictContent, 'utf8')
+    }
+    
+    // Store conflict state in metadata
+    const metaDir = path.join(dir, '.vcs-next')
+    await fs.promises.mkdir(metaDir, { recursive: true })
+    const localPath = path.join(metaDir, 'local.json')
+    let localMeta = { baseCommitId: currentSnap.commitId, baseFiles: currentSnap.files, pendingCommit: null, conflicts: conflicts.map(c => c.path) }
+    try {
+      const s = await fs.promises.readFile(localPath, 'utf8')
+      localMeta = { ...JSON.parse(s), conflicts: conflicts.map(c => c.path) }
+    } catch {}
+    await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+    
+    const message = opts.squash ? `Merge ${sourceBranch} into ${meta.branch} (squash)` : `Merge ${sourceBranch} into ${meta.branch}`
+    if (opts.json === 'true') {
+      print({ conflicts: conflicts.map(c => ({ path: c.path, line: c.line })), message }, true)
+    } else {
+      process.stdout.write(color(`\nMerge conflict detected!\n`, 'red'))
+      process.stdout.write(color(`Conflicts in ${conflicts.length} file(s):\n`, 'yellow'))
+      for (const c of conflicts) {
+        process.stdout.write(color(`  ${c.path}:${c.line}\n`, 'red'))
+      }
+      process.stdout.write(color(`\nResolve conflicts manually, then commit and push.\n`, 'yellow'))
+      process.stdout.write(color(`Files with conflicts have been marked with conflict markers:\n`, 'dim'))
+      process.stdout.write(color(`  <<<<<<< ${meta.branch}\n`, 'dim'))
+      process.stdout.write(color(`  =======\n`, 'dim'))
+      process.stdout.write(color(`  >>>>>>> ${sourceBranch}\n`, 'dim'))
+    }
+    return
+  }
+  
+  // Apply changes to filesystem
+  for (const ch of changes) {
+    const fp = path.join(dir, ch.path)
+    if (ch.type === 'delete') {
+      try { await fs.promises.unlink(fp) } catch {}
+    } else if (ch.type === 'write') {
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      await fs.promises.writeFile(fp, ch.content, 'utf8')
+    }
+  }
+  
+  // Update local metadata
+  const metaDir = path.join(dir, '.vcs-next')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  const localPath = path.join(metaDir, 'local.json')
+  let localMeta = { baseCommitId: currentSnap.commitId, baseFiles: currentSnap.files, pendingCommit: null }
+  try {
+    const s = await fs.promises.readFile(localPath, 'utf8')
+    localMeta = JSON.parse(s)
+  } catch {}
+  
+  const mergeMsg = opts.message || (opts.squash ? `Merge ${sourceBranch} into ${meta.branch} (squash)` : `Merge ${sourceBranch} into ${meta.branch}`)
+  
+  // Collect final state
+  const finalLocal = await collectLocal(dir)
+  const finalFiles = {}
+  for (const [p, v] of Object.entries(finalLocal)) {
+    finalFiles[p] = v.content
+  }
+  
+  // Set pending commit
+  localMeta.pendingCommit = { message: mergeMsg, files: finalFiles, createdAt: Date.now() }
+  await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+  
+  if (opts.json === 'true') {
+    print({ merged: sourceBranch, into: meta.branch, status: 'applied', changes: changes.length }, true)
+  } else {
+    process.stdout.write(color(`Merge ${sourceBranch} → ${meta.branch}: applied (${changes.length} changes)\n`, 'green'))
+  }
+  
+  if (opts.noPush !== 'true') {
+    await cmdPush({ dir, json: opts.json, message: mergeMsg })
+  }
+}
+
+async function cmdStash(sub, opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const metaDir = path.join(dir, '.vcs-next')
+  const stashDir = path.join(metaDir, 'stash')
+  await fs.promises.mkdir(stashDir, { recursive: true })
+  
+  if (sub === 'list' || sub === undefined) {
+    try {
+      const files = await fs.promises.readdir(stashDir)
+      const stashes = []
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          const content = await fs.promises.readFile(path.join(stashDir, f), 'utf8')
+          const stash = JSON.parse(content)
+          stashes.push({ id: f.replace('.json', ''), message: stash.message || '', createdAt: stash.createdAt || 0 })
+        }
+      }
+      stashes.sort((a, b) => b.createdAt - a.createdAt)
+      if (opts.json === 'true') {
+        print(stashes, true)
+      } else {
+        if (stashes.length === 0) {
+          process.stdout.write('No stashes found.\n')
+        } else {
+          process.stdout.write(color('Stashes:\n', 'bold'))
+          for (let i = 0; i < stashes.length; i++) {
+            const s = stashes[i]
+            const date = new Date(s.createdAt).toLocaleString()
+            process.stdout.write(`stash@{${i}}: ${s.message || '(no message)'} (${date})\n`)
+          }
+        }
+      }
+    } catch {
+      if (opts.json !== 'true') process.stdout.write('No stashes found.\n')
+      else print([], true)
+    }
+    return
+  }
+  
+  if (sub === 'save' || (sub === undefined && !opts.list)) {
+    const message = opts.message || 'WIP'
+    const local = await collectLocal(dir)
+    const files = {}
+    for (const [p, v] of Object.entries(local)) {
+      files[p] = v.content
+    }
+    const stashId = Date.now().toString()
+    const stash = { message, files, createdAt: Date.now() }
+    await fs.promises.writeFile(path.join(stashDir, `${stashId}.json`), JSON.stringify(stash, null, 2))
+    
+    // Restore to base state (discard local changes)
+    const meta = readRemoteMeta(dir)
+    const cfg = loadConfig()
+    const server = getServer(opts, cfg) || meta.server
+    const token = getToken(opts, cfg) || meta.token
+    await pullToDir(meta.repoId, meta.branch, dir, server, token)
+    
+    if (opts.json === 'true') {
+      print({ stashId, message }, true)
+    } else {
+      process.stdout.write(color(`Saved stash: ${message}\n`, 'green'))
+    }
+    return
+  }
+  
+  if (sub === 'pop' || sub === 'apply') {
+    const stashIndex = opts.index !== undefined ? parseInt(opts.index) : 0
+    try {
+      const files = await fs.promises.readdir(stashDir)
+      const stashes = []
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          const content = await fs.promises.readFile(path.join(stashDir, f), 'utf8')
+          const stash = JSON.parse(content)
+          stashes.push({ id: f.replace('.json', ''), ...stash })
+        }
+      }
+      stashes.sort((a, b) => b.createdAt - a.createdAt)
+      if (stashIndex >= stashes.length) throw new Error(`Stash index ${stashIndex} not found`)
+      const stash = stashes[stashIndex]
+      
+      // Apply stash files
+      for (const [p, content] of Object.entries(stash.files || {})) {
+        const fp = path.join(dir, p)
+        await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+        await fs.promises.writeFile(fp, content, 'utf8')
+      }
+      
+      if (sub === 'pop') {
+        // Remove stash
+        await fs.promises.unlink(path.join(stashDir, `${stash.id}.json`))
+      }
+      
+      if (opts.json === 'true') {
+        print({ applied: stash.id, message: stash.message }, true)
+      } else {
+        process.stdout.write(color(`${sub === 'pop' ? 'Popped' : 'Applied'} stash: ${stash.message || stash.id}\n`, 'green'))
+      }
+    } catch (err) {
+      throw new Error(`Stash operation failed: ${err.message}`)
+    }
+    return
+  }
+  
+  if (sub === 'drop') {
+    const stashIndex = opts.index !== undefined ? parseInt(opts.index) : 0
+    try {
+      const files = await fs.promises.readdir(stashDir)
+      const stashes = []
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          const content = await fs.promises.readFile(path.join(stashDir, f), 'utf8')
+          const stash = JSON.parse(content)
+          stashes.push({ id: f.replace('.json', ''), ...stash })
+        }
+      }
+      stashes.sort((a, b) => b.createdAt - a.createdAt)
+      if (stashIndex >= stashes.length) throw new Error(`Stash index ${stashIndex} not found`)
+      const stash = stashes[stashIndex]
+      await fs.promises.unlink(path.join(stashDir, `${stash.id}.json`))
+      
+      if (opts.json === 'true') {
+        print({ dropped: stash.id }, true)
+      } else {
+        process.stdout.write(color(`Dropped stash: ${stash.message || stash.id}\n`, 'green'))
+      }
+    } catch (err) {
+      throw new Error(`Drop stash failed: ${err.message}`)
+    }
+    return
+  }
+  
+  if (sub === 'clear') {
+    try {
+      const files = await fs.promises.readdir(stashDir)
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          await fs.promises.unlink(path.join(stashDir, f))
+        }
+      }
+      if (opts.json !== 'true') process.stdout.write(color('Cleared all stashes\n', 'green'))
+      else print({ cleared: true }, true)
+    } catch {
+      if (opts.json !== 'true') process.stdout.write('No stashes to clear.\n')
+      else print({ cleared: true }, true)
+    }
+    return
+  }
+  
+  throw new Error('Unknown stash subcommand')
+}
+
+async function cmdBranch(sub, opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = opts.repo ? { repoId: opts.repo, branch: '', server: getServer(opts, loadConfig()), token: getToken(opts, loadConfig()) } : readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+
+  if (sub === 'list' || sub === undefined) {
+    const url = new URL(`/api/repositories/${meta.repoId}/branches`, server).toString()
+    const data = await request('GET', url, null, token)
+    if (opts.json === 'true') {
+      print(data, true)
+    } else {
+      let current = meta.branch
+      try {
+        const head = fs.readFileSync(path.join(dir, '.git', 'HEAD'), 'utf8')
+        const m = head.match(/refs\/heads\/(.+)/)
+        if (m) current = m[1]
+      } catch {}
+      process.stdout.write(color('Branches:\n', 'bold'))
+      const list = (data.branches || []).map(b => ({ name: b.name, commitId: b.commitId || '' }))
+      for (const b of list) {
+        const isCur = b.name === current
+        const mark = isCur ? color('*', 'green') : ' '
+        const nameStr = isCur ? color(b.name, 'green') : color(b.name, 'cyan')
+        const idStr = color((b.commitId || '').slice(0, 7), 'dim')
+        process.stdout.write(` ${mark} ${nameStr} ${idStr}\n`)
+      }
+    }
+    return
+  }
+  if (sub === 'create') {
+    const name = opts.name
+    if (!name) throw new Error('Missing --name')
+    const baseBranch = opts.base || meta.branch
+    const body = { name, baseBranch }
+    const url = new URL(`/api/repositories/${meta.repoId}/branches`, server).toString()
+    const data = await request('POST', url, body, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  if (sub === 'delete') {
+    const name = opts.name
+    if (!name) throw new Error('Missing --name')
+    const u = new URL(`/api/repositories/${meta.repoId}/branches`, server)
+    u.searchParams.set('name', name)
+    const headers = token ? { Authorization: `Bearer ${token}` } : {}
+    const res = await fetch(u.toString(), { method: 'DELETE', headers })
+    if (!res.ok) {
+      const body = await res.text().catch(() => '')
+      throw new Error(`Branch delete failed: ${res.status} ${res.statusText} ${body}`)
+    }
+    const data = await res.json()
+    print(data, opts.json === 'true')
+    return
+  }
+  
+  throw new Error('Unknown branch subcommand')
+}
+
+async function cmdSwitch(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const branch = opts.branch
+  if (!branch) throw new Error('Missing --branch')
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  await pullToDir(meta.repoId, branch, dir, server, token)
+  print({ repoId: meta.repoId, branch, dir }, opts.json === 'true')
+}
+
+async function checkoutCommit(meta, dir, commitId, server, token) {
+  const snap = await fetchSnapshotByCommit(server, meta.repoId, commitId, token)
+  const files = snap.files || {}
+  const root = path.resolve(dir)
+  for (const [p, content] of Object.entries(files)) {
+    const fullPath = path.join(root, p)
+    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true })
+    await fs.promises.writeFile(fullPath, content, 'utf8')
+  }
+  const keep = new Set(Object.keys(files))
+  const localMap = await collectLocal(root)
+  for (const rel of Object.keys(localMap)) {
+    if (!keep.has(rel)) {
+      const fp = path.join(root, rel)
+      try { await fs.promises.unlink(fp) } catch {}
+    }
+  }
+  const metaDir = path.join(root, '.vcs-next')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  const remoteMeta = { repoId: meta.repoId, branch: meta.branch, commitId: snap.commitId || commitId, server, token: token || '' }
+  await fs.promises.writeFile(path.join(metaDir, 'remote.json'), JSON.stringify(remoteMeta, null, 2))
+  const gitDir = path.join(root, '.git')
+  await fs.promises.mkdir(gitDir, { recursive: true })
+  await fs.promises.writeFile(path.join(gitDir, 'HEAD'), commitId + '\n', 'utf8')
+  const localState = { baseCommitId: snap.commitId || commitId, baseFiles: files, pendingCommit: null }
+  await fs.promises.writeFile(path.join(metaDir, 'local.json'), JSON.stringify(localState, null, 2))
+  print({ repoId: meta.repoId, commit: commitId, dir }, token ? (false) : (opts && opts.json === 'true'))
+}
+
+async function cmdCheckout(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const branch = opts.branch
+  const commitId = opts.commit
+  if (commitId) {
+    await checkoutCommit(meta, dir, commitId, server, token)
+    return
+  }
+  if (!branch) throw new Error('Missing --branch or --commit')
+  await pullToDir(meta.repoId, branch, dir, server, token)
+  print({ repoId: meta.repoId, branch, dir }, opts.json === 'true')
+}
+
+async function cmdTag(sub, opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  if (sub === 'list') {
+    const url = new URL(`/api/repositories/${meta.repoId}/tags`, server).toString()
+    const data = await request('GET', url, null, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  if (sub === 'create') {
+    const name = opts.name
+    if (!name) throw new Error('Missing --name')
+    const body = { name, branchName: opts.branch || meta.branch }
+    const url = new URL(`/api/repositories/${meta.repoId}/tags`, server).toString()
+    const data = await request('POST', url, body, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  if (sub === 'delete') {
+    const name = opts.name
+    if (!name) throw new Error('Missing --name')
+    const u = new URL(`/api/repositories/${meta.repoId}/tags`, server)
+    u.searchParams.set('name', name)
+    const headers = token ? { Authorization: `Bearer ${token}` } : {}
+    const res = await fetch(u.toString(), { method: 'DELETE', headers })
+    if (!res.ok) throw new Error('delete failed')
+    const data = await res.json()
+    print(data, opts.json === 'true')
+    return
+  }
+  throw new Error('Unknown tag subcommand')
+}
+
+async function cmdPr(sub, opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  if (sub === 'list') {
+    const url = new URL(`/api/repositories/${meta.repoId}/pull-requests`, server).toString()
+    const data = await request('GET', url, null, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  if (sub === 'create') {
+    const title = opts.title
+    const sourceBranch = opts.source || meta.branch
+    const targetBranch = opts.target || meta.branch
+    if (!title) throw new Error('Missing --title')
+    const body = { title, description: opts.description || '', sourceBranch, targetBranch }
+    const url = new URL(`/api/repositories/${meta.repoId}/pull-requests`, server).toString()
+    const data = await request('POST', url, body, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  if (sub === 'merge') {
+    const prId = opts.id
+    if (!prId) throw new Error('Missing --id')
+    const url = new URL(`/api/repositories/${meta.repoId}/pull-requests/${prId}/merge`, server).toString()
+    const data = await request('POST', url, {}, token)
+    print(data, opts.json === 'true')
+    return
+  }
+  throw new Error('Unknown pr subcommand')
+}
+
+async function cmdCurrent(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  print({ repoId: meta.repoId, branch: meta.branch, server: meta.server, dir }, opts.json === 'true')
+}
+
+async function cmdHead(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  let commitId = ''
+  try {
+    const head = fs.readFileSync(path.join(dir, '.git', 'HEAD'), 'utf8')
+    const m = head.match(/refs\/heads\/(.+)/)
+    if (m) {
+      const ref = path.join(dir, '.git', 'refs', 'heads', m[1])
+      commitId = (await fs.promises.readFile(ref, 'utf8')).trim()
+    } else {
+      commitId = head.trim()
+    }
+  } catch {}
+  if (!commitId) {
+    const cfg = loadConfig()
+    const server = getServer(opts, cfg) || meta.server
+    const token = getToken(opts, cfg) || meta.token
+    const info = await request('GET', new URL(`/api/repositories/${meta.repoId}/branches`, server).toString(), null, token)
+    const found = (info.branches || []).find(b => b.name === meta.branch)
+    commitId = found ? (found.commitId || '') : ''
+  }
+  const out = { branch: meta.branch, commitId }
+  print(opts.json === 'true' ? out : (commitId || ''), opts.json === 'true')
+}
+
+async function cmdShow(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const commitId = opts.commit
+  if (!commitId) throw new Error('Missing --commit')
+  
+  const commit = await fetchCommitMeta(server, meta.repoId, commitId, token)
+  const parentId = (Array.isArray(commit.parents) && commit.parents[0]) || ''
+  const commitSnap = await fetchSnapshotByCommit(server, meta.repoId, commitId, token)
+  const parentSnap = parentId ? await fetchSnapshotByCommit(server, meta.repoId, parentId, token) : { files: {}, commitId: '' }
+  
+  if (opts.json === 'true') {
+    print({ commit: commitId, message: commit.message, author: commit.author, parents: commit.parents, files: Object.keys(commitSnap.files) }, true)
+  } else {
+    process.stdout.write(color(`commit ${commitId}\n`, 'yellow'))
+    if (commit.author) {
+      process.stdout.write(`Author: ${commit.author.name || ''} <${commit.author.email || ''}>\n`)
+    }
+    if (commit.committer) {
+      process.stdout.write(`Date: ${commit.committer.date ? new Date(commit.committer.date).toLocaleString() : ''}\n`)
+    }
+    process.stdout.write(`\n${commit.message || ''}\n\n`)
+    
+    // Show file changes
+    const allPaths = new Set([...Object.keys(parentSnap.files), ...Object.keys(commitSnap.files)])
+    const changed = []
+    for (const p of allPaths) {
+      const old = parentSnap.files[p]
+      const new_ = commitSnap.files[p]
+      if (old !== new_) {
+        if (old === undefined) changed.push({ path: p, type: 'added' })
+        else if (new_ === undefined) changed.push({ path: p, type: 'deleted' })
+        else changed.push({ path: p, type: 'modified' })
+      }
+    }
+    if (changed.length > 0) {
+      process.stdout.write(color(`\nFiles changed (${changed.length}):\n`, 'bold'))
+      for (const ch of changed) {
+        const colorCode = ch.type === 'added' ? 'green' : ch.type === 'deleted' ? 'red' : 'yellow'
+        process.stdout.write(color(`${ch.type === 'added' ? '+' : ch.type === 'deleted' ? '-' : 'M'} ${ch.path}\n`, colorCode))
+      }
+    }
+  }
+}
+
+async function cmdRevert(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  const commitId = opts.commit
+  if (!commitId) throw new Error('Missing --commit')
+  
+  // Get the commit to revert
+  const commit = await fetchCommitMeta(server, meta.repoId, commitId, token)
+  const commitSnap = await fetchSnapshotByCommit(server, meta.repoId, commitId, token)
+  const parentId = (Array.isArray(commit.parents) && commit.parents[0]) || ''
+  const parentSnap = parentId ? await fetchSnapshotByCommit(server, meta.repoId, parentId, token) : { files: {}, commitId: '' }
+  
+  // Get current state
+  await pullToDir(meta.repoId, meta.branch, dir, server, token)
+  const currentSnap = await fetchRemoteSnapshot(server, meta.repoId, meta.branch, token)
+  const localAfterPull = await collectLocal(dir)
+  
+  // Revert: apply inverse of commit changes
+  const conflicts = []
+  const changes = []
+  const allPaths = new Set([...Object.keys(parentSnap.files), ...Object.keys(commitSnap.files), ...Object.keys(currentSnap.files)])
+  
+  for (const p of allPaths) {
+    const base = parentSnap.files[p] !== undefined ? String(parentSnap.files[p]) : null
+    const commitContent = commitSnap.files[p] !== undefined ? String(commitSnap.files[p]) : null
+    const current = currentSnap.files[p] !== undefined ? String(currentSnap.files[p]) : null
+    const local = localAfterPull[p]?.content || null
+    
+    // Revert: we want to go from commit state back to parent state
+    // But check if current branch has changed this file
+    const commitChanged = base !== commitContent
+    const currentChanged = current !== base
+    
+    if (commitChanged) {
+      // Commit changed this file - we want to revert it
+      if (currentChanged && current !== base) {
+        // Conflict: current branch also changed this file
+        const line = firstDiffLine(String(local || ''), String(base || ''))
+        conflicts.push({ path: p, line, current: local, incoming: base })
+      } else {
+        // No conflict: revert to base
+        if (base !== null) {
+          if (local !== base) {
+            changes.push({ type: 'write', path: p, content: base })
+          }
+        } else {
+          // Base was null, commit added file - delete it
+          if (local !== null) {
+            changes.push({ type: 'delete', path: p })
+          }
+        }
+      }
+    }
+  }
+  
+  if (conflicts.length > 0) {
+    // Write conflict markers to files
+    for (const conflict of conflicts) {
+      const fp = path.join(dir, conflict.path)
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      const conflictContent = writeConflictMarkers(
+        conflict.current,
+        conflict.incoming,
+        meta.branch,
+        `revert-${commitId.slice(0,7)}`
+      )
+      await fs.promises.writeFile(fp, conflictContent, 'utf8')
+    }
+    
+    // Store conflict state in metadata
+    const metaDir = path.join(dir, '.vcs-next')
+    await fs.promises.mkdir(metaDir, { recursive: true })
+    const localPath = path.join(metaDir, 'local.json')
+    let localMeta = { baseCommitId: currentSnap.commitId, baseFiles: currentSnap.files, pendingCommit: null, conflicts: conflicts.map(c => c.path) }
+    try {
+      const s = await fs.promises.readFile(localPath, 'utf8')
+      localMeta = { ...JSON.parse(s), conflicts: conflicts.map(c => c.path) }
+    } catch {}
+    await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+    
+    if (opts.json === 'true') {
+      print({ conflicts: conflicts.map(c => ({ path: c.path, line: c.line })), message: `Revert ${commitId}` }, true)
+    } else {
+      process.stdout.write(color(`\nRevert conflict detected!\n`, 'red'))
+      process.stdout.write(color(`Conflicts in ${conflicts.length} file(s):\n`, 'yellow'))
+      for (const c of conflicts) {
+        process.stdout.write(color(`  ${c.path}:${c.line}\n`, 'red'))
+      }
+      process.stdout.write(color(`\nResolve conflicts manually, then commit and push.\n`, 'yellow'))
+      process.stdout.write(color(`Files with conflicts have been marked with conflict markers:\n`, 'dim'))
+      process.stdout.write(color(`  <<<<<<< ${meta.branch}\n`, 'dim'))
+      process.stdout.write(color(`  =======\n`, 'dim'))
+      process.stdout.write(color(`  >>>>>>> revert-${commitId.slice(0,7)}\n`, 'dim'))
+    }
+    return
+  }
+  
+  // Apply changes
+  for (const ch of changes) {
+    const fp = path.join(dir, ch.path)
+    if (ch.type === 'delete') {
+      try { await fs.promises.unlink(fp) } catch {}
+    } else if (ch.type === 'write') {
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      await fs.promises.writeFile(fp, ch.content, 'utf8')
+    }
+  }
+  
+  // Update metadata
+  const metaDir = path.join(dir, '.vcs-next')
+  const localPath = path.join(metaDir, 'local.json')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  let localMeta = { baseCommitId: currentSnap.commitId, baseFiles: currentSnap.files, pendingCommit: null }
+  try {
+    const s = await fs.promises.readFile(localPath, 'utf8')
+    localMeta = JSON.parse(s)
+  } catch {}
+  
+  const revertMsg = opts.message || `Revert "${commit.message || commitId}"`
+  const finalLocal = await collectLocal(dir)
+  const finalFiles = {}
+  for (const [p, v] of Object.entries(finalLocal)) {
+    finalFiles[p] = v.content
+  }
+  
+  localMeta.pendingCommit = { message: revertMsg, files: finalFiles, createdAt: Date.now() }
+  await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+  
+  if (opts.json === 'true') {
+    print({ reverted: commitId, changes: changes.length }, true)
+  } else {
+    process.stdout.write(color(`Reverted ${commitId.slice(0,7)}: ${changes.length} changes\n`, 'green'))
+  }
+  
+  if (opts.noPush !== 'true') {
+    await cmdPush({ dir, json: opts.json, message: revertMsg })
+  }
+}
+
+async function cmdReset(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const meta = readRemoteMeta(dir)
+  const cfg = loadConfig()
+  const server = getServer(opts, cfg) || meta.server
+  const token = getToken(opts, cfg) || meta.token
+  
+  const commitId = opts.commit || 'HEAD'
+  const mode = opts.mode || 'mixed' // soft, mixed, hard
+  const filePath = opts.path
+  
+  if (filePath) {
+    // Reset specific file (unstage)
+    const metaDir = path.join(dir, '.vcs-next')
+    const localPath = path.join(metaDir, 'local.json')
+    let localMeta = { baseCommitId: '', baseFiles: {}, pendingCommit: null }
+    try {
+      const s = await fs.promises.readFile(localPath, 'utf8')
+      localMeta = JSON.parse(s)
+    } catch {}
+    
+    // Restore file from base
+    const baseContent = localMeta.baseFiles[filePath]
+    if (baseContent !== undefined) {
+      const fp = path.join(dir, filePath)
+      await fs.promises.mkdir(path.dirname(fp), { recursive: true })
+      await fs.promises.writeFile(fp, String(baseContent), 'utf8')
+    }
+    
+    if (opts.json === 'true') {
+      print({ reset: filePath }, true)
+    } else {
+      process.stdout.write(color(`Reset ${filePath}\n`, 'green'))
+    }
+    return
+  }
+  
+  // Reset to commit
+  let targetSnap
+  if (commitId === 'HEAD') {
+    targetSnap = await fetchRemoteSnapshot(server, meta.repoId, meta.branch, token)
+  } else {
+    targetSnap = await fetchSnapshotByCommit(server, meta.repoId, commitId, token)
+  }
+  
+  if (mode === 'hard') {
+    // Hard reset: discard all changes, reset to commit
+    await pullToDir(meta.repoId, meta.branch, dir, server, token)
+    // Update to target commit if different
+    if (commitId !== 'HEAD') {
+      const files = targetSnap.files || {}
+      const root = path.resolve(dir)
+      for (const [p, content] of Object.entries(files)) {
+        const fullPath = path.join(root, p)
+        await fs.promises.mkdir(path.dirname(fullPath), { recursive: true })
+        await fs.promises.writeFile(fullPath, String(content), 'utf8')
+      }
+    }
+  } else if (mode === 'soft') {
+    // Soft reset: keep changes staged
+    // Just update base reference
+  } else {
+    // Mixed reset: keep changes unstaged (default)
+    await pullToDir(meta.repoId, meta.branch, dir, server, token)
+  }
+  
+  // Update metadata
+  const metaDir = path.join(dir, '.vcs-next')
+  const localPath = path.join(metaDir, 'local.json')
+  await fs.promises.mkdir(metaDir, { recursive: true })
+  const localMeta = { baseCommitId: targetSnap.commitId, baseFiles: targetSnap.files, pendingCommit: null }
+  await fs.promises.writeFile(localPath, JSON.stringify(localMeta, null, 2))
+  
+  if (opts.json === 'true') {
+    print({ reset: commitId, mode }, true)
+  } else {
+    process.stdout.write(color(`Reset to ${commitId} (${mode})\n`, 'green'))
+  }
+}
+
+async function cmdMv(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  const from = opts.from
+  const to = opts.to
+  if (!from || !to) throw new Error('Missing --from and --to')
+  
+  const fromPath = path.join(dir, from)
+  const toPath = path.join(dir, to)
+  
+  // Check if source exists
+  const stat = await fs.promises.stat(fromPath).catch(() => null)
+  if (!stat) throw new Error(`Source file not found: ${from}`)
+  
+  // Move file
+  await fs.promises.mkdir(path.dirname(toPath), { recursive: true })
+  await fs.promises.rename(fromPath, toPath)
+  
+  // If it's a tracked file, we need to update it in the next commit
+  // For now, just move it - the next commit will track the change
+  if (opts.json === 'true') {
+    print({ moved: { from, to } }, true)
+  } else {
+    process.stdout.write(color(`Moved ${from} → ${to}\n`, 'green'))
+  }
+}
+
+async function cmdAdd(opts) {
+  const dir = path.resolve(opts.dir || '.')
+  
+  // Handle --all flag
+  if (opts.all === 'true' || opts.all === true) {
+    const meta = readRemoteMeta(dir)
+    const cfg = loadConfig()
+    const server = getServer(opts, cfg) || meta.server
+    const token = getToken(opts, cfg) || meta.token
+    const remote = await fetchRemoteFilesMap(server, meta.repoId, meta.branch, token)
+    const local = await collectLocal(dir)
+    
+    // Stage all changes (add new, modified, delete removed)
+    const allPaths = new Set([...Object.keys(remote.map), ...Object.keys(local)])
+    let stagedCount = 0
+    for (const p of allPaths) {
+      const remoteId = remote.map[p]
+      const localId = local[p]?.id
+      if (remoteId !== localId) {
+        stagedCount++
+      }
+    }
+    
+    if (opts.json === 'true') {
+      print({ staged: stagedCount }, true)
+    } else {
+      process.stdout.write(color(`Staged ${stagedCount} changes\n`, 'green'))
+    }
+    return
+  }
+  
+  const p = opts.path
+  if (!p) throw new Error('Missing --path')
+  const abs = path.join(dir, p)
+  const exists = await fs.promises.stat(abs).catch(() => null)
+  if (opts.from) {
+    const src = path.resolve(opts.from)
+    const srcStat = await fs.promises.stat(src)
+    if (srcStat.isDirectory()) {
+      await copyDir(src, abs)
+      if (opts['commit-message']) {
+        await cmdCommit({ dir, message: opts['commit-message'], json: opts.json })
+        return
+      }
+      print({ addedDir: p, dir }, opts.json === 'true')
+      return
+    } else {
+      const targetStat = exists
+      const target = targetStat && targetStat.isDirectory() ? path.join(abs, path.basename(src)) : abs
+      await fs.promises.mkdir(path.dirname(target), { recursive: true })
+      await fs.promises.copyFile(src, target)
+      if (opts['commit-message']) {
+        await cmdCommit({ dir, message: opts['commit-message'], json: opts.json })
+        return
+      }
+      print({ added: path.relative(dir, target), dir }, opts.json === 'true')
+      return
+    }
+  }
+  if (p === '.' || (exists && exists.isDirectory())) {
+    if (!exists) await fs.promises.mkdir(abs, { recursive: true })
+    if (opts['commit-message']) {
+      await cmdCommit({ dir, message: opts['commit-message'], json: opts.json })
+      return
+    }
+    print({ addedDir: p, dir }, opts.json === 'true')
+    return
+  }
+  await fs.promises.mkdir(path.dirname(abs), { recursive: true })
+  const content = opts.content || ''
+  await fs.promises.writeFile(abs, content, 'utf8')
+  if (opts['commit-message']) {
+    await cmdCommit({ dir, message: opts['commit-message'], json: opts.json })
+    return
+  }
+  print({ added: p, dir }, opts.json === 'true')
+}
+
+function help() {
+  const h = [
+    'Usage: resulgit <group> <command> [options]',
+    '',
+    'Groups:',
+    '  auth set-token --token <token>',
+    '  auth set-server --server <url>',
+    '  auth login --email <email> --password <password> [--server <url>]',
+    '  auth register --username <name> --email <email> --password <password> [--displayName <text>] [--server <url>]',
+    '  repo list [--json]',
+    '  repo create --name <name> [--description <text>] [--visibility <private|public>] [--init]',
+  '  repo log --repo <id> [--branch <name>] [--json]',
+  '  repo head --repo <id> [--branch <name>] [--json]',
+  '  repo select [--workspace] (interactive select and clone/open)',
+    '  branch list|create|delete [--dir <path>] [--name <branch>] [--base <branch>]',
+    '  switch --branch <name> [--dir <path>]',
+    '  current [--dir <path>] (show active repo/branch)',
+    '  add <file> [--content <text>] [--from <src>] [--all] [--dir <path>] [--commit-message <text>]',
+    '  tag list|create|delete [--dir <path>] [--name <tag>] [--branch <name>]',
+    '  status [--dir <path>] [--json]',
+    '  diff [--dir <path>] [--path <file>] [--commit <id>] [--json]',
+    '  commit --message <text> [--dir <path>] [--json]',
+  '  push [--dir <path>] [--json]',
+  '  head [--dir <path>] [--json]',
+  '  rm --path <file> [--dir <path>] [--json]',
+    '  pull [--dir <path>]',
+  '  merge --branch <name> [--squash] [--no-push] [--dir <path>]',
+  '  stash [save|list|pop|apply|drop|clear] [--message <msg>] [--index <n>] [--dir <path>]',
+  '  restore --path <file> [--source <commit>] [--dir <path>]',
+  '  revert --commit <id> [--no-push] [--dir <path>]',
+  '  reset [--commit <id>] [--mode <soft|mixed|hard>] [--path <file>] [--dir <path>]',
+  '  show --commit <id> [--dir <path>] [--json]',
+  '  mv --from <old> --to <new> [--dir <path>]',
+  '',
+  'Conflict Resolution:',
+  '  When conflicts occur (merge/cherry-pick/revert), conflict markers are written to files:',
+  '    <<<<<<< HEAD (current changes)',
+  '    =======',
+  '    >>>>>>> incoming (incoming changes)',
+  '  Resolve conflicts manually, then commit and push. Push is blocked until conflicts are resolved.',
+  '  pr list|create|merge [--dir <path>] [--title <t>] [--id <id>] [--source <branch>] [--target <branch>]',
+  '  clone --repo <id> --branch <name> [--dest <dir>] [--server <url>] [--token <token>]',
+  '  workspace set-root --path <dir>',
+  '  cherry-pick --commit <id> [--branch <name>] [--no-push] [--dir <path>]',
+  '  checkout <branch>|--branch <name> | --commit <id> [--dir <path>]',
+    '',
+    'Global options:',
+    '  --server <url>  Override default server',
+    '  --token <tok>   Override stored token',
+    '  --json          JSON output'
+  ].join('\n')
+  process.stdout.write(h + '\n')
+}
+
+async function main() {
+  const { cmd, opts } = parseArgs(process.argv)
+  const cfg = loadConfig()
+  if (cmd.length === 0 || (cmd.length === 1 && (cmd[0] === 'help' || cmd[0] === '--help'))) {
+    help()
+    return
+  }
+  if (cmd[0] === 'auth') {
+    await cmdAuth(cmd[1], opts)
+    return
+  }
+  if (cmd[0] === 'repo') {
+    await cmdRepo(cmd[1], opts, cfg)
+    return
+  }
+  if (cmd[0] === 'clone') {
+    await cmdClone(opts, cfg)
+    return
+  }
+  if (cmd[0] === 'status') {
+    await cmdStatus(opts)
+    return
+  }
+  if (cmd[0] === 'diff') {
+    await cmdDiff(opts)
+    return
+  }
+  if (cmd[0] === 'commit') {
+    await cmdCommit(opts)
+    return
+  }
+  if (cmd[0] === 'push') {
+    await cmdPush(opts)
+    return
+  }
+  if (cmd[0] === 'rm') {
+    await cmdRm(opts)
+    return
+  }
+  if (cmd[0] === 'pull') {
+    await cmdPull(opts)
+    return
+  }
+  if (cmd[0] === 'branch') {
+    await cmdBranch(cmd[1], opts)
+    return
+  }
+  if (cmd[0] === 'switch') {
+    await cmdSwitch(opts)
+    return
+  }
+  if (cmd[0] === 'tag') {
+    await cmdTag(cmd[1], opts)
+    return
+  }
+  if (cmd[0] === 'pr') {
+    await cmdPr(cmd[1], opts)
+    return
+  }
+  if (cmd[0] === 'merge') {
+    await cmdMerge(opts)
+    return
+  }
+  if (cmd[0] === 'stash') {
+    await cmdStash(cmd[1], opts)
+    return
+  }
+  if (cmd[0] === 'restore') {
+    await cmdRestore(opts)
+    return
+  }
+  if (cmd[0] === 'revert') {
+    await cmdRevert(opts)
+    return
+  }
+  if (cmd[0] === 'reset') {
+    await cmdReset(opts)
+    return
+  }
+  if (cmd[0] === 'show') {
+    await cmdShow(opts)
+    return
+  }
+  if (cmd[0] === 'mv') {
+    await cmdMv(opts)
+    return
+  }
+  if (cmd[0] === 'cherry-pick') {
+    await cmdCherryPick(opts)
+    return
+  }
+  if (cmd[0] === 'checkout') {
+    if (!opts.branch && !opts.commit && cmd[1]) opts.branch = cmd[1]
+    await cmdCheckout(opts)
+    return
+  }
+  if (cmd[0] === 'head') {
+    await cmdHead(opts)
+    return
+  }
+  if (cmd[0] === 'workspace') {
+    if (cmd[1] === 'set-root') {
+      const p = opts.path
+      if (!p) throw new Error('Missing --path')
+      const cfg2 = saveConfig({ workspaceRoot: path.resolve(p) })
+      print({ workspaceRoot: cfg2.workspaceRoot }, opts.json === 'true')
+      return
+    }
+    throw new Error('Unknown workspace subcommand')
+  }
+  if (cmd[0] === 'current' || cmd[0] === 'which') {
+    await cmdCurrent(opts)
+    return
+  }
+  if (cmd[0] === 'add') {
+    if (!opts.path && cmd[1]) opts.path = cmd[1]
+    await cmdAdd(opts)
+    return
+  }
+  throw new Error('Unknown command')
+}
+
+function enableMouse() {
+  process.stdout.write('\x1b[?1000h')
+  process.stdout.write('\x1b[?1006h')
+}
+
+function disableMouse() {
+  process.stdout.write('\x1b[?1000l')
+  process.stdout.write('\x1b[?1006l')
+}
+
+async function tuiSelectRepo(repos, cfg, opts) {
+  const wsRoot = (opts.workspace ? process.cwd() : (cfg.workspaceRoot || path.join(os.homedir(), 'resulgit-workspace')))
+  await fs.promises.mkdir(wsRoot, { recursive: true })
+  const items = repos.map(r => ({ id: String(r.id || r._id || ''), name: r.name || '', defaultBranch: r.defaultBranch || 'main' }))
+  if (items.length === 0) {
+    print('No repositories available', false)
+    return
+  }
+  const lines = process.stdout.rows || 24
+  let idx = 0
+  const render = () => {
+    process.stdout.write('\x1b[2J\x1b[H')
+    process.stdout.write('Select a repository (↑/↓, Enter to open, q to quit)\n')
+    process.stdout.write(`Workspace: ${wsRoot}\n\n`)
+    const max = Math.max(0, lines - 5)
+    const start = Math.max(0, Math.min(idx - Math.floor(max / 2), items.length - max))
+    const end = Math.min(items.length, start + max)
+    for (let i = start; i < end; i++) {
+      const mark = i === idx ? '> ' : '  '
+      process.stdout.write(`${mark}${items[i].name} (${items[i].id})\n`)
+    }
+    process.stdout.write('\nMouse: click an item to select.\n')
+  }
+  const cleanup = () => {
+    disableMouse()
+    process.stdin.setRawMode(false)
+    process.stdin.pause()
+    process.stdout.write('\x1b[?25h')
+  }
+  process.stdout.write('\x1b[?25l')
+  enableMouse()
+  render()
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+  process.stdin.on('data', async (buf) => {
+    const s = buf.toString('utf8')
+    if (s === '\u0003') { // Ctrl-C
+      cleanup()
+      return
+    }
+    if (s === '\u001b[A') { // Up
+      idx = (idx + items.length - 1) % items.length
+      render()
+      return
+    }
+    if (s === '\u001b[B') { // Down
+      idx = (idx + 1) % items.length
+      render()
+      return
+    }
+    if (s === '\r') { // Enter
+      cleanup()
+      await openRepo(items[idx], wsRoot, cfg, opts)
+      return
+    }
+    if (s === 'q') {
+      cleanup()
+      return
+    }
+    if (s.startsWith('\u001b[')) {
+      const m = s.match(/\u001b\[<(?<btn>\d+);(?<x>\d+);(?<y>\d+)(?<type>[mM])/)
+      if (m && m.groups) {
+        const y = parseInt(m.groups.y, 10)
+        const headerLines = 3
+        const itemIdx = y - headerLines - 1
+        if (itemIdx >= 0 && itemIdx < items.length) {
+          idx = itemIdx
+          render()
+          if (m.groups.type === 'M') { // press
+            cleanup()
+            await openRepo(items[idx], wsRoot, cfg, opts)
+          }
+        }
+      }
+    }
+  })
+}
+
+async function openRepo(item, wsRoot, cfg, opts) {
+  const server = getServer(opts, cfg)
+  const token = getToken(opts, cfg)
+  const dest = path.join(wsRoot, item.name || item.id)
+  await pullToDir(item.id, item.defaultBranch || 'main', dest, server, token)
+  print({ opened: item.name, id: item.id, path: dest }, opts.json === 'true')
+}
+
+async function copyDir(src, dest) {
+  await fs.promises.mkdir(dest, { recursive: true })
+  const entries = await fs.promises.readdir(src, { withFileTypes: true })
+  for (const e of entries) {
+    if (e.name === '.git' || e.name === '.vcs-next') continue
+    const s = path.join(src, e.name)
+    const d = path.join(dest, e.name)
+    if (e.isDirectory()) {
+      await copyDir(s, d)
+    } else if (e.isFile()) {
+      await fs.promises.copyFile(s, d)
+    }
+  }
+}
+
+async function tuiSelectBranch(branches, current) {
+  const items = (branches || []).map((b) => ({ name: b.name || '', commitId: b.commitId || '' })).filter((b) => b.name)
+  if (items.length === 0) throw new Error('No branches available')
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const found = items.find((i) => i.name === current)
+    return (found ? found.name : items[0].name)
+  }
+  let idx = Math.max(0, items.findIndex((i) => i.name === current))
+  const render = () => {
+    process.stdout.write('\x1b[2J\x1b[H')
+    process.stdout.write(color('Select target branch for cherry-pick\n\n', 'bold'))
+    for (let i = 0; i < items.length; i++) {
+      const isCur = items[i].name === current
+      const mark = i === idx ? color('> ', 'yellow') : '  '
+      const star = isCur ? color('* ', 'green') : '  '
+      const nameStr = isCur ? color(items[i].name, 'green') : color(items[i].name, 'cyan')
+      const idStr = color((items[i].commitId || '').slice(0, 7), 'dim')
+      process.stdout.write(`${mark}${star}${nameStr} ${idStr}\n`)
+    }
+    process.stdout.write('\nUse ↑/↓ and Enter. Press q to cancel.\n')
+  }
+  const cleanup = (listener) => {
+    try { process.stdin.removeListener('data', listener) } catch {}
+    process.stdin.setRawMode(false)
+    process.stdin.pause()
+    process.stdout.write('\x1b[?25h')
+  }
+  process.stdout.write('\x1b[?25l')
+  render()
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+  return await new Promise((resolve, reject) => {
+    const onData = (buf) => {
+      const s = buf.toString('utf8')
+      if (s === '\u0003') { cleanup(onData); reject(new Error('Cancelled')); return }
+      if (s === '\u001b[A') { idx = (idx + items.length - 1) % items.length; render(); return }
+      if (s === '\u001b[B') { idx = (idx + 1) % items.length; render(); return }
+      if (s === 'q') { cleanup(onData); reject(new Error('Cancelled')); return }
+      if (s === '\r') { const name = items[idx].name; cleanup(onData); resolve(name); return }
+    }
+    process.stdin.on('data', onData)
+  })
+}
+
+main().catch((err) => {
+  process.stderr.write((err && err.message) ? err.message + '\n' : String(err) + '\n')
+  process.exit(1)
+})