git-workspace-bare 0.1.0

package/lib/init.js

@@ -0,0 +1,85 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import { spawnSync } from 'bare-subprocess'
+import repositoryPath from './repository-path.js'
+import { configPath, manifestDirectory, readRegistry } from './registry.js'
+
+export default function init(repository) {
+  const directory = repositoryPath(repository)
+  if (repository.includes('@')) throw new Error('Expected a manifest repository in owner/repo form')
+
+  if (fs.existsSync(configPath()) && manifestDirectory() !== directory) {
+    throw new Error('Workspace is already initialized with a different manifest repository')
+  }
+  let exists = true
+  try {
+    fs.lstatSync(directory)
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err
+    exists = false
+  }
+  if (!exists) {
+    fs.mkdirSync(path.dirname(directory), { recursive: true })
+    const remote = `git@github.com:${repository}.git`
+    const clone = spawnSync('git', ['clone', remote, directory])
+    if (clone.error) throw clone.error
+    if (clone.status !== 0) {
+      if (fs.existsSync(directory) && fs.readdirSync(directory).length > 0) {
+        throw new Error(clone.stderr.toString().trim() || 'Clone failed; destination is not empty')
+      }
+      console.error(`warning: could not clone ${repository}: ${clone.stderr.toString().trim()}`)
+      git(['init', directory])
+      git(['-C', directory, 'remote', 'add', 'origin', remote])
+      console.error('hint: initialized locally; create the remote repository and push when ready')
+    }
+  }
+
+  if (
+    fs.lstatSync(directory).isSymbolicLink() ||
+    !fs.lstatSync(path.join(directory, '.git')).isDirectory() ||
+    fs.realpathSync(git(['-C', directory, 'rev-parse', '--show-toplevel'])) !==
+      fs.realpathSync(directory)
+  ) {
+    throw new Error('Manifest destination must be a standalone Git repository')
+  }
+  const origin = git(['-C', directory, 'config', '--get', 'remote.origin.url'])
+  const match =
+    /^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/github\.com\/)([^/]+\/[^/]+?)\/?$/i.exec(
+      origin
+    )
+  if (!match || match[1].replace(/\.git$/i, '').toLowerCase() !== repository.toLowerCase()) {
+    throw new Error('Manifest repository is already initialized with a different origin')
+  }
+
+  const manifest = path.join(directory, 'workspace.json')
+  let hasManifest = true
+  try {
+    fs.lstatSync(manifest)
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err
+    hasManifest = false
+  }
+  if (!hasManifest) {
+    fs.writeFileSync(manifest, '[]\n')
+  } else {
+    readRegistry(manifest)
+  }
+  fs.mkdirSync(path.dirname(configPath()), { recursive: true })
+  const lock = configPath() + '.lock'
+  fs.mkdirSync(lock)
+  const pending = path.join(lock, 'config.json')
+  try {
+    fs.writeFileSync(pending, JSON.stringify({ manifestRepository: directory }, null, 2) + '\n')
+    fs.renameSync(pending, configPath())
+  } finally {
+    if (fs.existsSync(pending)) fs.unlinkSync(pending)
+    fs.rmdirSync(lock)
+  }
+}
+
+function git(args, options) {
+  const result = spawnSync('git', args, options)
+  if (result.error) throw result.error
+  if (result.status !== 0) throw new Error(result.stderr?.toString().trim() || 'Git command failed')
+  return result.stdout?.toString().replace(/\r?\n$/, '')
+}

package/lib/list.js

@@ -0,0 +1,6 @@
+import { readRegistry } from './registry.js'
+import repositoryName from './repository-name.js'
+
+export default function list() {
+  return readRegistry().map(repositoryName).sort()
+}

package/lib/map-concurrent.js

@@ -0,0 +1,22 @@
+export default async function mapConcurrent(items, map, limit = 4) {
+  const results = new Array(items.length)
+  let next = 0
+  let failed = false
+  let error
+
+  async function worker() {
+    while (!failed && next < items.length) {
+      const index = next++
+      try {
+        results[index] = await map(items[index])
+      } catch (err) {
+        failed = true
+        error ??= err
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker))
+  if (failed) throw error
+  return results
+}

package/lib/registry.js

@@ -0,0 +1,70 @@
+import fs from 'bare-fs'
+import os from 'bare-os'
+import path from 'bare-path'
+import repositoryPath from './repository-path.js'
+import repositoryName from './repository-name.js'
+
+export function configPath() {
+  return path.join(os.homedir(), '.config', 'git-workspace', 'config.json')
+}
+
+export function manifestDirectory() {
+  let config
+  try {
+    config = JSON.parse(fs.readFileSync(configPath(), 'utf8'))
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('Workspace is not initialized; run git workspace init owner/repo')
+    }
+    throw err
+  }
+  if (
+    !config ||
+    typeof config.manifestRepository !== 'string' ||
+    !path.isAbsolute(config.manifestRepository)
+  ) {
+    throw new Error('Invalid workspace config: manifestRepository must be an absolute path')
+  }
+  return config.manifestRepository
+}
+
+export function registryPath() {
+  return path.join(manifestDirectory(), 'workspace.json')
+}
+
+export function readRegistry(registry = registryPath()) {
+  let worktrees
+  try {
+    if (!fs.lstatSync(registry).isFile()) throw new Error('Manifest must be a regular file')
+    worktrees = 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')
+    }
+    throw err
+  }
+
+  if (!Array.isArray(worktrees) || !worktrees.every((entry) => typeof entry === 'string')) {
+    throw new Error('Invalid worktree registry')
+  }
+
+  return worktrees.map(repositoryPath)
+}
+
+export function updateRegistry(update, registry = registryPath()) {
+  const lock = path.join(manifestDirectory(), '.git', 'workspace.lock')
+  if (!fs.existsSync(path.join(manifestDirectory(), '.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 entries = worktrees.map(repositoryName)
+    fs.writeFileSync(pending, JSON.stringify(entries, null, 2) + '\n')
+    fs.renameSync(pending, registry)
+  } finally {
+    if (fs.existsSync(pending)) fs.unlinkSync(pending)
+    fs.rmdirSync(lock)
+  }
+}

package/lib/remove-empty-parents.js

@@ -0,0 +1,14 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+
+export default function removeEmptyParents(directory, owner) {
+  for (let parent = path.dirname(directory); parent !== owner; parent = path.dirname(parent)) {
+    try {
+      fs.rmdirSync(parent)
+    } catch (err) {
+      if (err.code === 'ENOENT') continue
+      if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST' || err.code === 'ENOTDIR') break
+      throw err
+    }
+  }
+}

package/lib/remove.js

@@ -0,0 +1,126 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import { spawnSync } from 'bare-subprocess'
+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'
+
+export default function remove(repository) {
+  const absolute = repositoryPath(repository)
+  let canonical = absolute
+  let exists = true
+  try {
+    canonical = fs.realpathSync(absolute)
+  } catch (err) {
+    if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err
+    exists = false
+  }
+
+  updateRegistry((worktrees) => {
+    const target = worktrees.includes(absolute) ? absolute : canonical
+    const [base, requested] = repository.split('@')
+    let branch = requested
+    if (requested && exists) {
+      const root = repositoryPath(base)
+      const common = (directory) =>
+        fs.realpathSync(
+          git(['-C', directory, 'rev-parse', '--path-format=absolute', '--git-common-dir'])
+        )
+      if (
+        fs.realpathSync(git(['-C', absolute, 'rev-parse', '--show-toplevel'])) !== canonical ||
+        common(root) !== common(absolute)
+      ) {
+        throw new Error('Destination is not a worktree of the requested repository')
+      }
+      branch = checkedOutBranch(absolute)
+      git(['-C', root, 'worktree', 'remove', canonical])
+    } else if (!requested && exists) {
+      removeRoot(base, absolute, canonical)
+    } else if (!worktrees.includes(target)) {
+      throw new Error('Repository is not registered')
+    }
+    if (requested) {
+      const root = repositoryPath(base)
+      if (branch) {
+        const ref = spawnSync('git', [
+          '-C',
+          root,
+          'show-ref',
+          '--verify',
+          '--quiet',
+          `refs/heads/${branch}`
+        ])
+        if (ref.error) throw ref.error
+        if (ref.status === 0) {
+          try {
+            git(['-C', root, 'branch', '-D', '--', branch])
+          } catch (err) {
+            throw new Error(
+              `Worktree directory is gone, but branch ${branch} could not be deleted. Registry entry retained; resolve the branch issue and retry.\n${err.message}`
+            )
+          }
+        } else if (ref.status !== 1) {
+          throw new Error(ref.stderr?.toString().trim() || 'Could not inspect Git branch')
+        }
+      }
+      removeEmptyParents(absolute, path.dirname(root))
+    }
+    return worktrees.filter((worktree) => worktree !== target)
+  })
+}
+
+function removeRoot(repository, directory, canonical) {
+  if (canonical === fs.realpathSync(manifestDirectory())) {
+    throw new Error('Cannot remove the active manifest repository')
+  }
+  if (fs.lstatSync(directory).isSymbolicLink()) {
+    throw new Error('Refusing to delete a root repository through a symbolic link')
+  }
+  const gitDirectory = path.join(canonical, '.git')
+  if (
+    !fs.lstatSync(gitDirectory).isDirectory() ||
+    fs.realpathSync(git(['-C', directory, 'rev-parse', '--show-toplevel'])) !== canonical ||
+    fs.realpathSync(
+      git(['-C', directory, 'rev-parse', '--path-format=absolute', '--git-common-dir'])
+    ) !== gitDirectory
+  ) {
+    throw new Error('Destination is not a standalone root repository')
+  }
+  const origin = git(['-C', directory, 'config', '--get', 'remote.origin.url'])
+  const match =
+    /^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/github\.com\/)([^/]+\/[^/]+?)\/?$/i.exec(
+      origin
+    )
+  if (!match || match[1].replace(/\.git$/i, '').toLowerCase() !== repository.toLowerCase()) {
+    throw new Error(`Destination origin does not match ${repository}`)
+  }
+  const worktrees = git(['-C', directory, 'worktree', 'list', '--porcelain', '-z'])
+    .split('\0')
+    .filter((field) => field.startsWith('worktree '))
+  if (worktrees.length !== 1) {
+    const err = new Error(`cannot remove ${repository}: linked worktrees exist`)
+    err.hint = 'remove the linked worktrees first'
+    throw err
+  }
+  if (
+    git([
+      '-C',
+      directory,
+      'status',
+      '--porcelain',
+      '--untracked-files=all',
+      '--ignore-submodules=none'
+    ])
+  ) {
+    throw new Error('Root repository has local changes or untracked files')
+  }
+  fs.rmSync(directory, { recursive: true })
+}
+
+function git(args) {
+  const result = spawnSync('git', args)
+  if (result.error) throw result.error
+  if (result.status !== 0) throw new Error(result.stderr?.toString().trim() || 'Git command failed')
+  return result.stdout?.toString().replace(/\r?\n$/, '')
+}

package/lib/rename-root.js

@@ -0,0 +1,173 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import { spawnSync } from 'bare-subprocess'
+import { manifestDirectory, updateRegistry } from './registry.js'
+import repositoryPath from './repository-path.js'
+import removeEmptyParents from './remove-empty-parents.js'
+
+export default function renameRoot(from, to) {
+  const source = repositoryPath(from)
+  const destination = repositoryPath(to)
+  if (from === to) throw new Error(`${to} is already the registered name`)
+
+  const moved = []
+  let originalConfig
+  try {
+    updateRegistry((worktrees) => {
+      if (!worktrees.includes(source)) throw new Error(`${from} is not registered`)
+      if (!exists(source)) throw new Error(`${from} is not checked out`)
+      const canonical = fs.realpathSync(source)
+      if (canonical === fs.realpathSync(manifestDirectory())) {
+        throw new Error('Cannot rename the active manifest repository')
+      }
+      const gitDirectory = path.join(canonical, '.git')
+      if (
+        fs.lstatSync(source).isSymbolicLink() ||
+        !fs.lstatSync(gitDirectory).isDirectory() ||
+        fs.realpathSync(git(source, 'rev-parse', '--show-toplevel')) !== canonical ||
+        fs.realpathSync(git(source, 'rev-parse', '--path-format=absolute', '--git-common-dir')) !==
+          gitDirectory
+      ) {
+        throw new Error('Source is not a standalone root repository')
+      }
+
+      const urls = configValues(source, 'remote.origin.url')
+      if (urls.length !== 1 || !matches(urls[0], from, to)) {
+        throw new Error(`Source origin does not match ${from} or ${to}`)
+      }
+      const pushurls = configValues(source, 'remote.origin.pushurl')
+      const entries = git(source, 'worktree', 'list', '--porcelain', '-z')
+        .split('\0\0')
+        .filter(Boolean)
+        .map((entry) => entry.split('\0'))
+      const moves = [[source, destination]]
+      for (const entry of entries.slice(1)) {
+        const directory = entry[0].slice('worktree '.length)
+        if (!exists(directory)) {
+          throw new Error(`Missing linked worktree: ${directory}; repair or prune it first`)
+        }
+        if (
+          fs.realpathSync(git(directory, 'rev-parse', '--show-toplevel')) !==
+            fs.realpathSync(directory) ||
+          fs.realpathSync(
+            git(directory, 'rev-parse', '--path-format=absolute', '--git-common-dir')
+          ) !== gitDirectory
+        ) {
+          throw new Error(`Linked worktree needs repair: ${directory}`)
+        }
+        // Worktree repair does not repair the separate Git links inside submodules.
+        if (
+          git(directory, 'ls-files', '--stage', '-z')
+            .split('\0')
+            .some((entry) => entry.startsWith('160000 '))
+        ) {
+          throw new Error(`Linked worktree contains submodules: ${directory}`)
+        }
+        if (!directory.startsWith(source + '@')) continue
+        if (entry.some((field) => field === 'locked' || field.startsWith('locked '))) {
+          throw new Error(`Linked worktree is locked: ${directory}`)
+        }
+        if (fs.lstatSync(directory).isSymbolicLink()) {
+          throw new Error(`Linked worktree is a symbolic link: ${directory}`)
+        }
+        moves.push([directory, destination + directory.slice(source.length)])
+      }
+      const mapping = new Map(moves)
+      for (const directory of worktrees) {
+        if (directory.startsWith(source + '@') && !mapping.has(directory)) {
+          throw new Error(
+            `Registered worktree is missing or does not belong to ${from}: ${directory}`
+          )
+        }
+        if (directory === destination || directory.startsWith(destination + '@')) {
+          throw new Error(`${to} already has registered checkouts`)
+        }
+      }
+      for (const [, target] of moves) {
+        if (exists(target)) throw new Error(`${target} already exists`)
+        // Resolve parents before any moves, including nested branch destinations.
+        fs.mkdirSync(path.dirname(target), { recursive: true })
+      }
+
+      originalConfig = fs.readFileSync(path.join(source, '.git', 'config'))
+      for (const [oldPath, newPath] of moves) {
+        fs.renameSync(oldPath, newPath)
+        moved.push([oldPath, newPath])
+      }
+      const linked = entries.slice(1).map((entry) => {
+        const directory = entry[0].slice('worktree '.length)
+        return mapping.get(directory) || directory
+      })
+      git(destination, 'worktree', 'repair', ...linked)
+      git(destination, 'config', 'remote.origin.url', replaceURL(urls[0], from, to))
+      if (pushurls.length) {
+        git(destination, 'config', '--unset-all', 'remote.origin.pushurl')
+        for (const url of pushurls) {
+          git(destination, 'config', '--add', 'remote.origin.pushurl', replaceURL(url, from, to))
+        }
+      }
+      return worktrees.map((directory) => mapping.get(directory) || directory)
+    })
+  } catch (err) {
+    if (moved.length) {
+      try {
+        for (const [oldPath, newPath] of moved.slice().reverse()) fs.renameSync(newPath, oldPath)
+        fs.writeFileSync(path.join(source, '.git', 'config'), originalConfig)
+        git(source, 'worktree', 'repair', ...moved.slice(1).map(([oldPath]) => oldPath))
+      } catch (rollback) {
+        err.message += `\nCould not fully restore local paths; inspect ${source} and ${destination}: ${rollback.message}`
+      }
+    }
+    throw err
+  }
+  for (const [oldPath] of moved.slice(1)) removeEmptyParents(oldPath, path.dirname(source))
+  console.error(
+    `hint: origin now points to ${to}; rename or transfer the repository on GitHub separately if needed`
+  )
+}
+
+function matches(url, from, to) {
+  const match = parseURL(url)
+  return match && [from.toLowerCase(), to.toLowerCase()].includes(match[2].toLowerCase())
+}
+
+function parseURL(url) {
+  return /^(git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/github\.com\/)([^/]+\/[^/]+?)(\.git)?(\/?)$/i.exec(
+    url
+  )
+}
+
+function replaceURL(url, from, to) {
+  const match = parseURL(url)
+  if (!match || match[2].toLowerCase() !== from.toLowerCase()) return url
+  return match[1] + to + (match[3] || '') + match[4]
+}
+
+function configValues(directory, key) {
+  const result = spawnSync('git', ['-C', directory, 'config', '--null', '--get-all', key])
+  if (result.error) throw result.error
+  if (result.status === 1) return []
+  if (result.status !== 0) {
+    throw new Error(result.stderr.toString().trim() || 'Could not inspect Git config')
+  }
+  return result.stdout.toString().split('\0').slice(0, -1)
+}
+
+function exists(directory) {
+  try {
+    fs.lstatSync(directory)
+    return true
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err
+    return false
+  }
+}
+
+function git(directory, ...args) {
+  const result = spawnSync('git', ['-C', directory, ...args])
+  if (result.error) throw result.error
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.toString().trim() || 'Git command failed')
+  }
+  return result.stdout?.toString().replace(/\r?\n$/, '')
+}

package/lib/rename.js

@@ -0,0 +1,97 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import { spawnSync } from 'bare-subprocess'
+import { 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 renameRoot from './rename-root.js'
+
+export default function rename(from, to) {
+  const source = repositoryPath(from)
+  const destination = repositoryPath(to)
+  const [base, requested] = from.split('@')
+  const [target, branch] = to.split('@')
+  if (!requested && !branch) return renameRoot(from, to)
+  if (!requested || !branch) {
+    throw new Error('Use owner/repo on both sides, or owner/repo@branch on both sides')
+  }
+  if (base !== target) {
+    throw new Error(`Cannot rename a worktree of ${base} into ${target}`)
+  }
+  if (source === destination) {
+    throw new Error(`${to} is already the registered name`)
+  }
+  git(['check-ref-format', '--branch', branch])
+
+  let canonical
+  try {
+    canonical = fs.realpathSync(source)
+  } catch (err) {
+    if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err
+    throw new Error(`${from} is not checked out`)
+  }
+
+  const root = repositoryPath(base)
+  const common = (directory) =>
+    fs.realpathSync(
+      git(['-C', directory, 'rev-parse', '--path-format=absolute', '--git-common-dir'])
+    )
+  if (
+    fs.realpathSync(git(['-C', source, 'rev-parse', '--show-toplevel'])) !== canonical ||
+    common(root) !== common(source)
+  ) {
+    throw new Error('Destination is not a worktree of the requested repository')
+  }
+
+  const current = checkedOutBranch(source)
+  if (!current) {
+    throw new Error(`${from} has a detached HEAD; check out a branch before renaming`)
+  }
+  if (current !== branch && hasRef(root, `refs/heads/${branch}`)) {
+    throw new Error(`Branch ${branch} already exists`)
+  }
+  if (fs.existsSync(destination)) {
+    throw new Error(`${destination} already exists`)
+  }
+
+  updateRegistry((worktrees) => {
+    const registered = worktrees.includes(source) ? source : canonical
+    if (!worktrees.includes(registered)) {
+      throw new Error(`${from} is not registered`)
+    }
+    fs.mkdirSync(path.dirname(destination), { recursive: true })
+    git(['-C', root, 'worktree', 'move', canonical, destination])
+    if (current !== branch) {
+      git(['-C', root, 'branch', '-m', current, branch])
+      retargetUpstream(root, branch)
+    }
+    removeEmptyParents(source, path.dirname(root))
+    return worktrees.map((worktree) => (worktree === registered ? destination : worktree))
+  })
+}
+
+function retargetUpstream(root, branch) {
+  const remote = spawnSync('git', ['-C', root, 'config', '--get', `branch.${branch}.remote`])
+  if (remote.error) throw remote.error
+  if (remote.status === 1) return
+  if (remote.status !== 0) {
+    throw new Error(remote.stderr?.toString().trim() || 'Could not inspect Git config')
+  }
+  git(['-C', root, 'config', `branch.${branch}.merge`, `refs/heads/${branch}`])
+}
+
+function hasRef(root, ref) {
+  const result = spawnSync('git', ['-C', root, 'show-ref', '--verify', '--quiet', ref])
+  if (result.error) throw result.error
+  if (result.status === 0) return true
+  if (result.status === 1) return false
+  throw new Error(result.stderr?.toString().trim() || 'Could not inspect Git refs')
+}
+
+function git(args) {
+  const result = spawnSync('git', args)
+  if (result.error) throw result.error
+  if (result.status !== 0) throw new Error(result.stderr?.toString().trim() || 'Git command failed')
+  return result.stdout?.toString().replace(/\r?\n$/, '')
+}

package/lib/report-error.js

@@ -0,0 +1,9 @@
+import { isTTY } from 'bare-tty'
+
+export default function reportError(err) {
+  const label = isTTY(2) ? '\x1b[31merror:\x1b[0m' : 'error:'
+  const message = err.message.replace(/^(?:error|fatal):\s*/i, '')
+  console.error(`${label} ${message}`)
+  if (err.hint) console.error(`hint: ${err.hint}`)
+  Bare.exitCode = 1
+}

package/lib/repository-name.js

@@ -0,0 +1,14 @@
+import os from 'bare-os'
+import path from 'bare-path'
+import repositoryPath from './repository-path.js'
+
+export default function repositoryName(worktree) {
+  const workspace = path.join(os.homedir(), 'workspace')
+  const repository = path.relative(workspace, worktree).split(path.sep).join('/')
+  try {
+    repositoryPath(repository)
+  } catch {
+    throw new Error(`Registered path is outside the owner/repo layout: ${worktree}`)
+  }
+  return repository
+}

package/lib/repository-path.js

@@ -0,0 +1,18 @@
+import os from 'bare-os'
+import path from 'bare-path'
+
+export default function repositoryPath(repository) {
+  if (
+    !/^[a-z0-9][a-z0-9-]*\/[a-z0-9_.-]+(?:@[a-z0-9_][a-z0-9_.-]*(?:\/[a-z0-9_][a-z0-9_.-]*)*)?$/i.test(
+      repository
+    )
+  ) {
+    throw new Error('Expected owner/repo or owner/repo@branch')
+  }
+  const [owner, ...parts] = repository.split('/')
+  const name = parts.join('/')
+  const base = name.split('@')[0]
+  if (base === '.' || base === '..') throw new Error('Invalid repository name')
+
+  return path.join(os.homedir(), 'workspace', owner, name)
+}