git-workspace-bare 0.1.1 → 0.3.0

package/lib/pull.js

@@ -0,0 +1,269 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import { spawnSync } from 'bare-subprocess'
+import { manifestDirectory, readManifest } from './registry.js'
+import { readCheckpoint, readCommitRef, recordCheckpoint, snapshot } from './checkpoint.js'
+import { emptyManifest, manifestNames } from './manifest.js'
+import planPull, { changes } from './plan-pull.js'
+import applyPull, { layoutAfter, pendingRename } from './apply-pull.js'
+import { readPullState, writePullState, statePath, targetRef, lockPull } from './pull-state.js'
+import repositoryPath from './repository-path.js'
+import Hooks from './hooks.js'
+import { validateHookProgress } from './hook-context.js'
+
+export default function pull({ dryRun = false, noHooks = false } = {}) {
+  const directory = manifestDirectory()
+  const hooks = new Hooks({ noHooks: noHooks || dryRun })
+  if (
+    fs.lstatSync(directory).isSymbolicLink() ||
+    !fs.lstatSync(path.join(directory, '.git')).isDirectory()
+  ) {
+    throw new Error('Manifest must be a standalone Git repository')
+  }
+  const unlock = lockPull(directory)
+  try {
+    const manifest = path.join(directory, 'workspace.json')
+    const local = readManifest(manifest)
+    const contents = fs.readFileSync(manifest, 'utf8')
+    if (
+      fs.realpathSync(git(directory, ['rev-parse', '--show-toplevel'])) !==
+      fs.realpathSync(directory)
+    ) {
+      throw new Error('Manifest must be a standalone Git repository')
+    }
+    const head = git(directory, ['rev-parse', '--verify', 'HEAD^{commit}'])
+    if (git(directory, ['status', '--porcelain', '--untracked-files=all'])) {
+      throw new Error(
+        'Manifest repository has uncommitted changes; commit or stash them before pulling'
+      )
+    }
+    if (JSON.stringify(local) !== JSON.stringify(snapshot(directory, head))) {
+      throw new Error('workspace.json differs from HEAD')
+    }
+    const symbolic = run(directory, ['symbolic-ref', '--quiet', '--short', 'HEAD'])
+    if (symbolic.status === 1) {
+      throw new Error('Manifest repository has a detached HEAD; check out a branch before pulling')
+    }
+    if (symbolic.status !== 0) fail(symbolic)
+    const branch = symbolic.stdout.toString().trim()
+    const progress = readPullState(directory)
+    if (progress) return resume(directory, progress, head, branch, dryRun, hooks)
+    const remote = config(directory, `branch.${branch}.remote`) || 'origin'
+    const merge = config(directory, `branch.${branch}.merge`) || `refs/heads/${branch}`
+    if (remote === '.' || !merge.startsWith('refs/heads/')) {
+      throw new Error('Manifest branch must track a remote branch')
+    }
+    git(directory, ['check-ref-format', merge])
+    git(directory, ['remote', 'get-url', remote])
+    const applied = readCheckpoint(directory)
+    if (applied && !ancestor(directory, applied, head)) {
+      throw new Error('Manifest HEAD does not descend from the locally applied commit')
+    }
+
+    git(directory, [
+      'fetch',
+      '--no-tags',
+      '--no-recurse-submodules',
+      '--no-auto-maintenance',
+      '--',
+      remote,
+      merge
+    ])
+    const fetched = git(directory, ['rev-parse', '--verify', 'FETCH_HEAD^{commit}'])
+    let target = fetched
+    if (ancestor(directory, fetched, head)) target = head
+    else if (!ancestor(directory, head, fetched)) {
+      throw new Error(
+        'Local and remote manifest histories have diverged; resolve them before pulling'
+      )
+    }
+    const previous = applied ? snapshot(directory, applied) : emptyManifest()
+    const desired = snapshot(directory, target)
+    const plan = planPull(previous, desired, directory)
+    if (
+      git(directory, ['rev-parse', '--verify', 'HEAD^{commit}']) !== head ||
+      readCheckpoint(directory) !== applied ||
+      fs.readFileSync(manifest, 'utf8') !== contents ||
+      git(directory, ['status', '--porcelain', '--untracked-files=all'])
+    ) {
+      throw new Error('Local manifest state changed during planning; retry')
+    }
+    const result = {
+      ...plan,
+      head,
+      fetched,
+      target,
+      applied,
+      remote,
+      branch: merge.slice('refs/heads/'.length),
+      dryRun
+    }
+    if (dryRun || plan.blockers.length) return result
+    const state = {
+      version: 1,
+      head,
+      target,
+      applied,
+      remote,
+      merge,
+      localBranch: branch,
+      completed: 0,
+      pending: false
+    }
+    const pinned = readCommitRef(directory, targetRef)
+    git(directory, [
+      'update-ref',
+      '--no-deref',
+      targetRef,
+      target,
+      pinned || '0'.repeat(target.length)
+    ])
+    writePullState(directory, state)
+    execute(directory, state, previous, desired, hooks)
+    return result
+  } finally {
+    unlock()
+  }
+}
+
+function resume(directory, state, head, branch, dryRun, hooks) {
+  const previous = state.applied ? snapshot(directory, state.applied) : emptyManifest()
+  const desired = snapshot(directory, state.target)
+  const original = changes(previous, desired)
+  validateHookProgress(state, original.actions)
+  const applied = readCheckpoint(directory)
+  const finished = state.completed === original.actions.length && !state.pending
+  if (
+    original.blockers.length ||
+    state.completed > original.actions.length ||
+    (state.pending && state.completed === original.actions.length) ||
+    branch !== state.localBranch ||
+    ![state.head, state.target].includes(head) ||
+    ((state.completed > 0 || state.pending) && head !== state.target) ||
+    !ancestor(directory, state.head, state.target) ||
+    (state.applied && !ancestor(directory, state.applied, state.head)) ||
+    (applied !== state.applied && !(finished && applied === state.target)) ||
+    readCommitRef(directory, targetRef) !== state.target
+  ) {
+    throw new Error(
+      'Manifest or local pull progress changed unexpectedly; inspect .git/workspace-pull.json'
+    )
+  }
+  const layout = layoutAfter(previous, desired, original.actions.slice(0, state.completed))
+  const interrupted = state.pending ? original.actions[state.completed] : null
+  let plan
+  if (interrupted && pendingRename(interrupted)) {
+    plan = { actions: original.actions.slice(state.completed), blockers: [] }
+    if (dryRun) {
+      plan.blockers.push(
+        'Interrupted rename needs repair before remaining changes can be checked; rerun git workspace pull'
+      )
+    }
+  } else plan = planPull(layout, desired, directory)
+  const result = {
+    ...plan,
+    head,
+    fetched: state.target,
+    target: state.target,
+    applied: state.applied,
+    remote: state.remote,
+    branch: state.merge.slice('refs/heads/'.length),
+    dryRun,
+    resumed: true,
+    completed: state.completed
+  }
+  if (dryRun) return result
+  // execute repeats preflight after recovering the pending operation.
+  execute(directory, state, previous, desired, hooks, true)
+  return result
+}
+
+function execute(directory, state, previous, desired, hooks, resumed = false) {
+  if (git(directory, ['rev-parse', '--verify', 'HEAD^{commit}']) !== state.target) {
+    git(directory, [
+      '-c',
+      'submodule.recurse=false',
+      'merge',
+      '--ff-only',
+      '--no-edit',
+      '--no-stat',
+      state.target
+    ])
+  }
+  applyPull(directory, state, previous, desired, hooks, resumed)
+  if (
+    git(directory, ['rev-parse', '--verify', 'HEAD^{commit}']) !== state.target ||
+    ![state.applied, state.target].includes(readCheckpoint(directory)) ||
+    git(directory, ['status', '--porcelain', '--untracked-files=all'])
+  ) {
+    throw new Error(
+      'Manifest state changed during pull; resolve the changes and rerun git workspace pull'
+    )
+  }
+  recordCheckpoint(directory, {
+    replacedPaths: new Set(manifestNames(desired).map(repositoryPath))
+  })
+  // Keep the target pinned until progress is removed, including a crash after verification.
+  fs.unlinkSync(statePath(directory))
+  git(directory, ['update-ref', '--no-deref', '-d', targetRef, state.target])
+}
+
+export function formatPlan(plan) {
+  const lines = [`Manifest: ${plan.remote}/${plan.branch}`]
+  if (plan.resumed) lines.push(`Resuming saved pull (${plan.completed} changes already completed)`)
+  const preview = plan.dryRun || plan.blockers.length
+  if (plan.target !== plan.head) {
+    lines.push(preview ? 'Would fast-forward the manifest' : 'Fast-forwarded the manifest')
+  } else if (plan.fetched !== plan.head) {
+    lines.push('Manifest is ahead of the remote; pushing remains manual')
+  } else {
+    lines.push('Manifest is up to date')
+  }
+  if (!plan.applied) {
+    lines.push(
+      preview
+        ? 'First setup: existing matching checkouts would be adopted'
+        : 'First setup: existing matching checkouts adopted'
+    )
+  }
+  for (const action of plan.actions) {
+    if (action.type === 'rename') lines.push(`rename ${action.from} -> ${action.to}`)
+    else lines.push(`${action.present ? 'adopt' : action.type} ${action.from || action.to}`)
+  }
+  if (!plan.actions.length) lines.push('No layout changes planned')
+  for (const blocker of plan.blockers) lines.push(`blocked: ${blocker}`)
+  if (plan.dryRun) lines.push('Dry run: no manifest checkout or workspace changes applied')
+  else if (plan.blockers.length) lines.push('No manifest checkout or workspace changes applied')
+  else lines.push('Workspace applied; managed repositories were not fetched or pulled')
+  return lines.join('\n')
+}
+
+function config(directory, key) {
+  const result = run(directory, ['config', '--get', key])
+  if (result.status === 1) return null
+  if (result.status !== 0) fail(result)
+  return result.stdout.toString().trim()
+}
+
+function ancestor(directory, from, to) {
+  const result = run(directory, ['merge-base', '--is-ancestor', from, to])
+  if (result.status === 1) return false
+  if (result.status !== 0) fail(result)
+  return true
+}
+
+function run(directory, args) {
+  const result = spawnSync('git', ['--no-optional-locks', '-C', directory, ...args])
+  if (result.error) throw result.error
+  return result
+}
+
+function fail(result) {
+  throw new Error(result.stderr.toString().trim() || 'Git command failed')
+}
+
+function git(directory, args) {
+  const result = run(directory, args)
+  if (result.status !== 0) fail(result)
+  return result.stdout.toString().replace(/\r?\n$/, '')
+}

package/lib/push-manifest.js

@@ -0,0 +1,53 @@
+import { spawnSync } from 'bare-subprocess'
+import networkEnvironment from './git-network-environment.js'
+
+export default function pushManifest(directory) {
+  try {
+    const symbolic = spawnSync('git', [
+      '-C',
+      directory,
+      'symbolic-ref',
+      '--quiet',
+      '--short',
+      'HEAD'
+    ])
+    if (!symbolic.error && !symbolic.signal && symbolic.status === 1) {
+      throw new Error('Manifest repository has a detached HEAD; check out a branch before pushing')
+    }
+    const branch = output(symbolic)
+    const remote = config(directory, `branch.${branch}.remote`) || 'origin'
+    const merge = config(directory, `branch.${branch}.merge`) || `refs/heads/${branch}`
+    if (remote === '.' || !merge.startsWith('refs/heads/')) {
+      throw new Error('Manifest branch must track a remote branch')
+    }
+    git(directory, ['push', '--set-upstream', '--no-follow-tags', '--', remote, `HEAD:${merge}`], {
+      env: networkEnvironment(directory)
+    })
+  } catch (err) {
+    console.error(`warning: could not push workspace manifest: ${err.message}`)
+    console.error(
+      'hint: changes are saved locally; repeat add to retry, or push the manifest branch manually'
+    )
+  }
+}
+
+function config(directory, key) {
+  const result = spawnSync('git', ['-C', directory, 'config', '--get', key])
+  if (result.error) throw result.error
+  if (!result.signal && result.status === 1) return null
+  return output(result)
+}
+
+function git(directory, args, options) {
+  return output(spawnSync('git', ['-C', directory, ...args], options))
+}
+
+function output(result) {
+  if (result.error) throw result.error
+  if (result.signal || result.status !== 0) {
+    throw new Error(
+      result.stderr?.toString().trim() || `Git command failed (${result.signal || result.status})`
+    )
+  }
+  return result.stdout.toString().trim()
+}

package/lib/registry.js

@@ -3,6 +3,7 @@ import os from 'bare-os'
 import path from 'bare-path'
 import repositoryPath from './repository-path.js'
 import repositoryName from './repository-name.js'
+import { manifestNames, updateManifest, validateManifest } from './manifest.js'
 
 export function configPath() {
   return path.join(os.homedir(), '.config', 'git-workspace', 'config.json')
@@ -33,10 +34,14 @@ export function registryPath() {
 }
 
 export function readRegistry(registry = registryPath()) {
-  let worktrees
+  return manifestNames(readManifest(registry)).map(repositoryPath)
+}
+
+export function readManifest(registry = registryPath()) {
+  let manifest
   try {
     if (!fs.lstatSync(registry).isFile()) throw new Error('Manifest must be a regular file')
-    worktrees = JSON.parse(fs.readFileSync(registry, 'utf8'))
+    manifest = JSON.parse(fs.readFileSync(registry, 'utf8'))
   } catch (err) {
     if (err.code === 'ENOENT') {
       throw new Error('Workspace is not initialized; run git workspace init owner/repo')
@@ -44,24 +49,30 @@ export function readRegistry(registry = registryPath()) {
     throw err
   }
 
-  if (!Array.isArray(worktrees) || !worktrees.every((entry) => typeof entry === 'string')) {
-    throw new Error('Invalid worktree registry')
-  }
-
-  return worktrees.map(repositoryPath)
+  validateManifest(manifest)
+  return manifest
 }
 
-export function updateRegistry(update, registry = registryPath()) {
-  const lock = path.join(manifestDirectory(), '.git', 'workspace.lock')
-  if (!fs.existsSync(path.join(manifestDirectory(), '.git'))) {
+export function updateRegistry(
+  update,
+  {
+    directory = manifestDirectory(),
+    registry = path.join(directory, 'workspace.json'),
+    rename
+  } = {}
+) {
+  const lock = path.join(directory, '.git', 'workspace.lock')
+  if (!fs.existsSync(path.join(directory, '.git'))) {
     throw new Error('Workspace is not initialized; run git workspace init owner/repo')
   }
   fs.mkdirSync(lock)
   const pending = path.join(lock, 'worktrees.json')
   try {
-    const worktrees = update(readRegistry(registry))
+    const previous = readManifest(registry)
+    const worktrees = update(manifestNames(previous).map(repositoryPath))
     const entries = worktrees.map(repositoryName)
-    fs.writeFileSync(pending, JSON.stringify(entries, null, 2) + '\n')
+    const manifest = updateManifest(previous, entries, rename)
+    fs.writeFileSync(pending, JSON.stringify(manifest, null, 2) + '\n')
     fs.renameSync(pending, registry)
   } finally {
     if (fs.existsSync(pending)) fs.unlinkSync(pending)

package/lib/remove.js

@@ -5,8 +5,28 @@ import { manifestDirectory, updateRegistry } from './registry.js'
 import repositoryPath from './repository-path.js'
 import checkedOutBranch from './checked-out-branch.js'
 import removeEmptyParents from './remove-empty-parents.js'
+import commitManifest from './commit-manifest.js'
+import { refreshCheckpoint } from './checkpoint.js'
+import { assertNoPendingPull } from './pull-state.js'
+import { withPostHooks } from './hook-context.js'
 
-export default function remove(repository) {
+export default function remove(repository, options = {}) {
+  assertNoPendingPull()
+  return withPostHooks('remove', { repository }, options, () => {
+    removeCheckout(repository)
+    try {
+      commitManifest(manifestDirectory(), `Remove ${repository}`)
+    } catch (err) {
+      err.message = `Removed ${repository}, but could not commit the manifest: ${err.message}`
+      err.hint =
+        'the checkout is already removed; resolve the Git error and commit only workspace.json in the manifest repository'
+      throw err
+    }
+    refreshCheckpoint()
+  })
+}
+
+export function removeCheckout(repository, { update = updateRegistry } = {}) {
   const absolute = repositoryPath(repository)
   let canonical = absolute
   let exists = true
@@ -17,9 +37,14 @@ export default function remove(repository) {
     exists = false
   }
 
-  updateRegistry((worktrees) => {
+  update((worktrees) => {
     const target = worktrees.includes(absolute) ? absolute : canonical
     const [base, requested] = repository.split('@')
+    if (!requested && worktrees.some((worktree) => worktree.startsWith(absolute + '@'))) {
+      const err = new Error(`cannot remove ${repository}: linked worktrees exist`)
+      err.hint = 'remove the linked worktrees first'
+      throw err
+    }
     let branch = requested
     if (requested && exists) {
       const root = repositoryPath(base)