git-worktree-organize 1.0.0

package/src/detect.ts

@@ -0,0 +1,95 @@
+import { existsSync, statSync, readFileSync } from 'node:fs'
+import { join, resolve, isAbsolute } from 'node:path'
+import { execSync } from 'node:child_process'
+
+export type RepoConfig =
+  | { type: 'standard';      gitdir: string; mainWorktree: string }
+  | { type: 'bare-root';     gitdir: string }
+  | { type: 'bare-hub';      gitdir: string }
+  | { type: 'bare-dotgit';   gitdir: string }
+  | { type: 'bare-external'; gitdir: string }
+
+/**
+ * Read core.bare from a git config file at `gitdir/config`.
+ * Returns true if set to "true", false if set to "false" or not set.
+ */
+function readCoreBare(gitdir: string): boolean {
+  try {
+    const result = execSync(`git --git-dir=${gitdir} config --get core.bare`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim()
+    return result === 'true'
+  } catch {
+    // exit code 1 means key not found — treat as false
+    return false
+  }
+}
+
+/**
+ * Detect the type of git repository at `repoPath`.
+ * Throws if the path is not a recognized git repo or is a linked worktree.
+ */
+export async function detect(repoPath: string): Promise<RepoConfig> {
+  const gitEntryPath = join(repoPath, '.git')
+  const gitEntryExists = existsSync(gitEntryPath)
+
+  if (gitEntryExists) {
+    const stat = statSync(gitEntryPath)
+
+    if (stat.isDirectory()) {
+      // .git is a directory — standard or bare-dotgit
+      const isbare = readCoreBare(gitEntryPath)
+      if (isbare) {
+        return { type: 'bare-dotgit', gitdir: gitEntryPath }
+      } else {
+        return { type: 'standard', gitdir: gitEntryPath, mainWorktree: repoPath }
+      }
+    } else if (stat.isFile()) {
+      // .git is a file — parse gitdir
+      const contents = readFileSync(gitEntryPath, 'utf8')
+      const firstLine = contents.split('\n')[0].trim()
+      const match = firstLine.match(/^gitdir:\s*(.+)$/)
+      if (!match) {
+        throw new Error(`not a git repository: ${repoPath}`)
+      }
+      const rawGitdir = match[1].trim()
+      const absGitdir = isAbsolute(rawGitdir)
+        ? rawGitdir
+        : resolve(repoPath, rawGitdir)
+
+      // Linked worktree: resolved path contains /worktrees/
+      if (absGitdir.includes('/worktrees/')) {
+        throw new Error('is a linked worktree, not a repo root')
+      }
+
+      // Validate the resolved gitdir looks like a git object store
+      if (
+        !existsSync(join(absGitdir, 'HEAD')) ||
+        !existsSync(join(absGitdir, 'objects')) ||
+        !existsSync(join(absGitdir, 'refs'))
+      ) {
+        throw new Error(`gitdir does not appear to be a git repository: ${absGitdir}`)
+      }
+
+      // bare-hub: resolved path ends with .bare
+      if (absGitdir.endsWith('.bare')) {
+        return { type: 'bare-hub', gitdir: absGitdir }
+      }
+
+      // bare-external: points elsewhere
+      return { type: 'bare-external', gitdir: absGitdir }
+    }
+  }
+
+  // No .git entry — check for bare-root (HEAD + refs/ + objects/ at root)
+  const headExists    = existsSync(join(repoPath, 'HEAD'))
+  const refsExists    = existsSync(join(repoPath, 'refs'))
+  const objectsExists = existsSync(join(repoPath, 'objects'))
+
+  if (headExists && refsExists && objectsExists) {
+    return { type: 'bare-root', gitdir: repoPath }
+  }
+
+  throw new Error(`not a git repository: ${repoPath}`)
+}

package/src/fs.ts

@@ -0,0 +1,22 @@
+import { statSync, renameSync } from 'node:fs'
+import { $ } from 'bun'
+
+/**
+ * Move `src` to `dest`.
+ * Uses rename() on the same filesystem; falls back to copy+delete across filesystems.
+ */
+export async function move(src: string, dest: string): Promise<void> {
+  if (samefs(src, dest)) {
+    renameSync(src, dest)
+  } else {
+    await $`cp -a ${src} ${dest}`.quiet()
+    await $`rm -rf ${src}`.quiet()
+  }
+}
+
+/**
+ * Returns true if `a` and `b` are on the same filesystem (same device number).
+ */
+export function samefs(a: string, b: string): boolean {
+  return statSync(a).dev === statSync(b).dev
+}

package/src/git.ts

@@ -0,0 +1,40 @@
+import { $ } from 'bun'
+
+/**
+ * Run a git command and return stdout as a string.
+ * Throws if the command exits non-zero.
+ */
+export async function git(args: string[], options?: { cwd?: string; env?: Record<string, string> }): Promise<string> {
+  const proc = $`git ${args}`.quiet()
+  if (options?.cwd) proc.cwd(options.cwd)
+  if (options?.env) proc.env({ ...process.env, ...options.env })
+  const result = await proc
+  return result.stdout.toString()
+}
+
+/**
+ * Read a git config value. Returns null if the key is not set.
+ */
+export async function gitConfig(key: string, options?: { gitdir?: string; cwd?: string }): Promise<string | null> {
+  const env: Record<string, string> = {}
+  if (options?.gitdir) env['GIT_DIR'] = options.gitdir
+
+  try {
+    const result = await git(['config', '--get', key], { cwd: options?.cwd, env })
+    return result.trimEnd()
+  } catch (err: any) {
+    // git config --get exits with code 1 when the key is not set
+    if (err?.exitCode === 1) return null
+    throw err
+  }
+}
+
+/**
+ * Set a git config value.
+ */
+export async function setGitConfig(key: string, value: string, options?: { gitdir?: string; cwd?: string }): Promise<void> {
+  const env: Record<string, string> = {}
+  if (options?.gitdir) env['GIT_DIR'] = options.gitdir
+
+  await git(['config', key, value], { cwd: options?.cwd, env })
+}

package/src/migrate.ts

@@ -0,0 +1,162 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, renameSync, statSync } from 'node:fs'
+import { join, dirname, basename, resolve } from 'node:path'
+import { $ } from 'bun'
+import type { RepoConfig } from './detect.ts'
+import { listWorktrees } from './worktrees.ts'
+import { setGitConfig } from './git.ts'
+
+/**
+ * Move src to dest. Uses rename if on same filesystem, cp+rm otherwise.
+ * Unlike fs.ts move(), this handles the case where dest does not yet exist
+ * by statting the parent of dest for the filesystem check.
+ */
+async function moveDir(src: string, dest: string): Promise<void> {
+  const destForStat = existsSync(dest) ? dest : dirname(dest)
+  if (statSync(src).dev === statSync(destForStat).dev) {
+    renameSync(src, dest)
+  } else {
+    await $`cp -a ${src} ${dest}`.quiet()
+    await $`rm -rf ${src}`.quiet()
+  }
+}
+
+export interface MigrateOptions {
+  source: string
+  dest: string
+}
+
+/**
+ * Sanitize a branch name for use as a directory name (replace / with -).
+ */
+export function sanitizeBranch(branch: string): string {
+  return branch.replace(/\//g, '-')
+}
+
+/**
+ * Orchestrate the full migration of a git repo into the bare-hub layout.
+ * Returns the path to the created hub directory.
+ */
+export async function migrate(config: RepoConfig, options: MigrateOptions): Promise<string> {
+  const source = resolve(options.source)
+  const dest = options.dest
+    ? resolve(options.dest)
+    : join(dirname(source), basename(source) + '-bare')
+
+  // Check dest/.bare doesn't already exist
+  const destBare = join(dest, '.bare')
+  if (existsSync(destBare)) {
+    throw new Error(`'${destBare}' already exists`)
+  }
+
+  // Step 1: Read worktrees, filter out bare entries
+  const allWorktrees = await listWorktrees(source)
+  const worktrees = allWorktrees.filter(wt => !wt.isBare)
+
+  // Step 2: Collision check on sanitized names
+  const seen = new Map<string, string>()
+  for (const wt of worktrees) {
+    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`
+    const safe = sanitizeBranch(branch)
+    if (seen.has(safe)) {
+      throw new Error(`branch name collision: '${seen.get(safe)}' and '${branch}' both map to '${safe}'`)
+    }
+    seen.set(safe, branch)
+  }
+
+  // Step 3: mkdir -p dest/.bare
+  mkdirSync(destBare, { recursive: true })
+
+  // Step 4: Copy git database: cp -a <source_gitdir>/. dest/.bare/
+  await $`cp -a ${config.gitdir + '/.'}  ${destBare + '/'}`.quiet()
+
+  // Step 5: Set core.bare = true
+  await setGitConfig('core.bare', 'true', { gitdir: destBare })
+
+  // Step 6: Set remote.origin.fetch
+  await setGitConfig('remote.origin.fetch', '+refs/heads/*:refs/remotes/origin/*', { gitdir: destBare })
+
+  // Step 7: Write dest/.git file
+  writeFileSync(join(dest, '.git'), 'gitdir: ./.bare\n')
+
+  // Step 8: If standard, handle main worktree
+  if (config.type === 'standard') {
+    const mainBranch = worktrees[0].branch!
+    const mainSafe = sanitizeBranch(mainBranch)
+    const mainDest = join(dest, mainSafe)
+
+    // Read HEAD content from dest/.bare/HEAD
+    const mainHeadContent = readFileSync(join(destBare, 'HEAD'), 'utf8')
+
+    // Remove source/.git directory
+    await $`rm -rf ${join(source, '.git')}`.quiet()
+
+    // Move source dir → mainDest
+    await moveDir(source, mainDest)
+
+    // Create dest/.bare/worktrees/mainSafe/ dir
+    const mainAdminDir = join(destBare, 'worktrees', mainSafe)
+    mkdirSync(mainAdminDir, { recursive: true })
+
+    // Write gitdir, commondir, HEAD
+    writeFileSync(join(mainAdminDir, 'gitdir'), mainDest + '/.git\n')
+    writeFileSync(join(mainAdminDir, 'commondir'), '../../\n')
+    const headToWrite = mainHeadContent.endsWith('\n') ? mainHeadContent : mainHeadContent + '\n'
+    writeFileSync(join(mainAdminDir, 'HEAD'), headToWrite)
+
+    // Move index if it exists
+    const bareIndex = join(destBare, 'index')
+    if (existsSync(bareIndex)) {
+      renameSync(bareIndex, join(mainAdminDir, 'index'))
+    }
+
+    // Write mainDest/.git
+    writeFileSync(join(mainDest, '.git'), `gitdir: ${mainAdminDir}\n`)
+
+    // Process linked worktrees starting at index 1
+    for (let i = 1; i < worktrees.length; i++) {
+      await processLinkedWorktree(worktrees[i], dest, destBare)
+    }
+  } else {
+    // Step 9: Not standard — process all linked worktrees starting at index 0
+    for (const wt of worktrees) {
+      await processLinkedWorktree(wt, dest, destBare)
+    }
+  }
+
+  return dest
+}
+
+async function processLinkedWorktree(
+  wt: { path: string; head: string; branch: string | null; isBare: boolean },
+  dest: string,
+  destBare: string,
+): Promise<void> {
+  const wtSrc = wt.path
+  const wtBranch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`
+  const wtSafe = sanitizeBranch(wtBranch)
+  const wtDest = join(dest, wtSafe)
+
+  // Move wtSrc → wtDest
+  await moveDir(wtSrc, wtDest)
+
+  // Read wtDest/.git file, parse gitdir: <oldPath>
+  const gitFileContent = readFileSync(join(wtDest, '.git'), 'utf8')
+  const match = gitFileContent.match(/^gitdir:\s*(.+)/m)
+  if (!match) {
+    console.warn(`Could not parse .git file in ${wtDest}`)
+    return
+  }
+  const oldPath = match[1].trim()
+  const adminName = basename(oldPath)
+  const newAdmin = join(destBare, 'worktrees', adminName)
+
+  // Write wtDest/.git pointing to new admin dir
+  writeFileSync(join(wtDest, '.git'), `gitdir: ${newAdmin}\n`)
+
+  // Update admin dir's gitdir if it exists
+  if (existsSync(newAdmin)) {
+    writeFileSync(join(newAdmin, 'gitdir'), wtDest + '/.git\n')
+  } else {
+    console.warn(`Admin dir ${newAdmin} does not exist for worktree ${wtDest}`)
+  }
+}

package/src/worktrees.ts

@@ -0,0 +1,54 @@
+import { $ } from 'bun'
+
+export interface Worktree {
+  path: string
+  head: string
+  branch: string | null  // null = detached HEAD
+  isBare: boolean
+}
+
+/**
+ * Parse the output of `git worktree list --porcelain` into Worktree objects.
+ */
+export function parsePorcelain(output: string): Worktree[] {
+  const worktrees: Worktree[] = []
+  const blocks = output.trim().split(/\n\n+/)
+
+  for (const block of blocks) {
+    if (!block.trim()) continue
+
+    const lines = block.trim().split('\n')
+    let path = ''
+    let head = ''
+    let branch: string | null = null
+    let isBare = false
+
+    for (const line of lines) {
+      if (line.startsWith('worktree ')) {
+        path = line.slice('worktree '.length)
+      } else if (line.startsWith('HEAD ')) {
+        head = line.slice('HEAD '.length)
+      } else if (line.startsWith('branch ')) {
+        const ref = line.slice('branch '.length)
+        branch = ref.startsWith('refs/heads/') ? ref.slice('refs/heads/'.length) : ref
+      } else if (line === 'detached') {
+        branch = null
+      } else if (line === 'bare') {
+        isBare = true
+        branch = null
+      }
+    }
+
+    worktrees.push({ path, head, branch, isBare })
+  }
+
+  return worktrees
+}
+
+/**
+ * List all worktrees for the repo at `repoPath`.
+ */
+export async function listWorktrees(repoPath: string): Promise<Worktree[]> {
+  const result = await $`git -C ${repoPath} worktree list --porcelain`.text()
+  return parsePorcelain(result)
+}

package/test/__bun-shim__.ts

@@ -0,0 +1,78 @@
+/**
+ * Minimal shim for `import { $ } from 'bun'` when running under Vitest (Node.js).
+ * Implements the tagged-template shell API that the tests use.
+ */
+import { spawnSync } from 'node:child_process'
+
+class ShellOutput {
+  private _stdout: string
+  private _stderr: string
+  private _exitCode: number
+
+  constructor(stdout: string, stderr: string, exitCode: number) {
+    this._stdout = stdout
+    this._stderr = stderr
+    this._exitCode = exitCode
+  }
+
+  text() { return this._stdout }
+  get stdout() { return Buffer.from(this._stdout) }
+  get stderr() { return Buffer.from(this._stderr) }
+  get exitCode() { return this._exitCode }
+}
+
+class ShellPromise extends Promise<ShellOutput> {
+  private _cmd: string[]
+
+  constructor(cmd: string[]) {
+    let resolve_: (v: ShellOutput) => void
+    let reject_: (e: unknown) => void
+    super((res, rej) => { resolve_ = res; reject_ = rej })
+    this._cmd = cmd
+
+    // Run synchronously but resolve asynchronously so it's awaitable
+    Promise.resolve().then(() => {
+      try {
+        const result = spawnSync(cmd[0], cmd.slice(1), {
+          encoding: 'utf8',
+          stdio: ['inherit', 'pipe', 'pipe'],
+        })
+        const exitCode = result.status ?? 1
+        const out = new ShellOutput(result.stdout ?? '', result.stderr ?? '', exitCode)
+        if (exitCode !== 0) {
+          const err = new Error(`Command failed: ${cmd.join(' ')}\n${result.stderr ?? ''}`)
+          ;(err as any).exitCode = exitCode
+          reject_!(err)
+        } else {
+          resolve_!(out)
+        }
+      } catch (e) {
+        reject_!(e)
+      }
+    })
+  }
+
+  quiet(): ShellPromise {
+    // Already quiet (stderr captured, not printed)
+    return this
+  }
+}
+
+function buildCmd(strings: TemplateStringsArray, ...values: unknown[]): string[] {
+  // Combine template parts and interpolated values into a flat array of tokens
+  const parts: string[] = []
+  strings.forEach((str, i) => {
+    // Split the static part by whitespace
+    parts.push(...str.trim().split(/\s+/).filter(Boolean))
+    if (i < values.length) {
+      const val = String(values[i]).trim()
+      if (val) parts.push(val)
+    }
+  })
+  return parts
+}
+
+export function $(strings: TemplateStringsArray, ...values: unknown[]): ShellPromise {
+  const cmd = buildCmd(strings, ...values)
+  return new ShellPromise(cmd)
+}

package/test/detect.test.ts

@@ -0,0 +1,99 @@
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { $ } from 'bun'
+import { describe, it, expect } from 'vitest'
+import { detect } from '../src/detect.ts'
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), 'gwt-detect-'))
+}
+
+async function makeCommit(dir: string) {
+  await $`git -C ${dir} config user.email "test@test.com"`.quiet()
+  await $`git -C ${dir} config user.name "Test"`.quiet()
+  await $`git -C ${dir} commit --allow-empty -m "init"`.quiet()
+}
+
+describe('detect', () => {
+  it('standard: git init + commit → type standard', async () => {
+    const dir = tempDir()
+    await $`git -C ${dir} init`.quiet()
+    await makeCommit(dir)
+
+    const result = await detect(dir)
+    expect(result).toEqual({
+      type: 'standard',
+      gitdir: join(dir, '.git'),
+      mainWorktree: dir,
+    })
+  })
+
+  it('bare-root: git init --bare → type bare-root', async () => {
+    const dir = tempDir()
+    await $`git -C ${dir} init --bare`.quiet()
+
+    const result = await detect(dir)
+    expect(result).toEqual({
+      type: 'bare-root',
+      gitdir: dir,
+    })
+  })
+
+  it('bare-dotgit: git init + core.bare=true → type bare-dotgit', async () => {
+    const dir = tempDir()
+    await $`git -C ${dir} init`.quiet()
+    // Set core.bare = true in .git/config
+    await $`git -C ${dir} config core.bare true`.quiet()
+
+    const result = await detect(dir)
+    expect(result).toEqual({
+      type: 'bare-dotgit',
+      gitdir: join(dir, '.git'),
+    })
+  })
+
+  it('bare-hub: .git file pointing to .bare dir → type bare-hub', async () => {
+    const dir = tempDir()
+    const bareDir = join(dir, '.bare')
+    mkdirSync(bareDir)
+    await $`git -C ${bareDir} init --bare`.quiet()
+    writeFileSync(join(dir, '.git'), 'gitdir: ./.bare\n')
+
+    const result = await detect(dir)
+    expect(result).toEqual({
+      type: 'bare-hub',
+      gitdir: bareDir,
+    })
+  })
+
+  it('bare-external: .git file pointing to external gitdir → type bare-external', async () => {
+    const dir = tempDir()
+    const extDir = join(dir, 'extgit')
+    mkdirSync(extDir)
+    await $`git -C ${extDir} init --bare`.quiet()
+    writeFileSync(join(dir, '.git'), 'gitdir: ./extgit\n')
+
+    const result = await detect(dir)
+    expect(result).toEqual({
+      type: 'bare-external',
+      gitdir: extDir,
+    })
+  })
+
+  it('reject linked worktree: detect on worktree dir throws', async () => {
+    const mainDir = tempDir()
+    const wtDir = join(tempDir(), 'wt')
+    await $`git -C ${mainDir} init`.quiet()
+    await makeCommit(mainDir)
+    await $`git -C ${mainDir} worktree add ${wtDir}`.quiet()
+
+    await expect(detect(wtDir)).rejects.toThrow('linked worktree')
+  })
+
+  it('reject not a git repo: plain dir throws', async () => {
+    const dir = tempDir()
+
+    await expect(detect(dir)).rejects.toThrow('not a git repository')
+  })
+})

package/test/helpers/repo.ts

@@ -0,0 +1,75 @@
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, statSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { $ } from 'bun'
+
+/** Create a temp directory and return its path. */
+export function makeTempDir(): string {
+  return mkdtempSync(join(tmpdir(), 'git-worktree-organize-'))
+}
+
+/**
+ * Create a standard git repo (non-bare, .git/ dir) with one commit.
+ * Adds extra worktrees for each branch name supplied in `branches`.
+ */
+export async function makeStandardRepo(dir: string, branches: string[] = []): Promise<void> {
+  await $`git init ${dir}`.quiet()
+  await $`git -C ${dir} config user.email "test@test.com"`.quiet()
+  await $`git -C ${dir} config user.name "Test"`.quiet()
+  await $`git -C ${dir} commit --allow-empty -m "init"`.quiet()
+
+  for (const branch of branches) {
+    const wtDir = join(dir + '-' + branch.replace(/\//g, '-'))
+    await $`git -C ${dir} worktree add -b ${branch} ${wtDir}`.quiet()
+  }
+}
+
+/**
+ * Create a bare repo at `dir` (clone --bare equivalent).
+ */
+export async function makeBareRootRepo(dir: string): Promise<void> {
+  await $`git init --bare ${dir}`.quiet()
+  await $`git -C ${dir} config user.email "test@test.com"`.quiet()
+  await $`git -C ${dir} config user.name "Test"`.quiet()
+}
+
+/**
+ * Create a bare-hub repo (already in hub layout: .bare/ + .git file).
+ */
+export async function makeBareHubRepo(dir: string): Promise<void> {
+  const bareDir = join(dir, '.bare')
+  mkdirSync(bareDir, { recursive: true })
+  await $`git init --bare ${bareDir}`.quiet()
+  await $`git -C ${bareDir} config user.email "test@test.com"`.quiet()
+  await $`git -C ${bareDir} config user.name "Test"`.quiet()
+  writeFileSync(join(dir, '.git'), 'gitdir: ./.bare\n')
+}
+
+/**
+ * Assert the hub structure at `dir` is valid.
+ */
+export async function assertHubStructure(dir: string): Promise<void> {
+  const bareDir = join(dir, '.bare')
+  if (!existsSync(bareDir) || !statSync(bareDir).isDirectory()) {
+    throw new Error(`assertHubStructure: ${bareDir} does not exist or is not a directory`)
+  }
+  const gitFile = join(dir, '.git')
+  if (!existsSync(gitFile) || !statSync(gitFile).isFile()) {
+    throw new Error(`assertHubStructure: ${gitFile} does not exist or is not a file`)
+  }
+  const gitFileContent = readFileSync(gitFile, 'utf8')  // eslint-disable-line @typescript-eslint/no-use-before-define
+  if (!gitFileContent.includes('gitdir: ./.bare')) {
+    throw new Error(`assertHubStructure: ${gitFile} does not contain 'gitdir: ./.bare'`)
+  }
+  // Assert git worktree list succeeds
+  await $`git -C ${dir} worktree list`.quiet()
+}
+
+/**
+ * Assert that a worktree for `branch` is functional (git status succeeds).
+ */
+export async function assertWorktreeWorks(dir: string, branch: string): Promise<void> {
+  const safeBranch = branch.replace(/\//g, '-')
+  const wtPath = join(dir, safeBranch)
+  await $`git -C ${wtPath} status`.quiet()
+}