git-worktree-organize 1.0.0

package/test/migrate.test.ts

@@ -0,0 +1,124 @@
+import { existsSync } from 'node:fs'
+import { join, dirname, basename } from 'node:path'
+import { $ } from 'bun'
+import { describe, it, expect } from 'vitest'
+import { migrate } from '../src/migrate.ts'
+import { detect } from '../src/detect.ts'
+import {
+  makeStandardRepo,
+  makeBareRootRepo,
+  makeBareHubRepo,
+  assertHubStructure,
+  assertWorktreeWorks,
+  makeTempDir,
+} from './helpers/repo.ts'
+
+describe('migrate', () => {
+  it('standard repo with extra worktree → hub layout', async () => {
+    const src = makeTempDir()
+    await makeStandardRepo(src, ['feature'])
+    const config = await detect(src)
+    const dest = src + '-hub'
+
+    await migrate(config, { source: src, dest })
+
+    await assertHubStructure(dest)
+    await assertWorktreeWorks(dest, 'main')
+    await assertWorktreeWorks(dest, 'feature')
+  })
+
+  it('standard repo with no extra worktrees → hub with just main', async () => {
+    const src = makeTempDir()
+    await makeStandardRepo(src)
+    const config = await detect(src)
+    const dest = src + '-hub'
+
+    await migrate(config, { source: src, dest })
+
+    await assertHubStructure(dest)
+    await assertWorktreeWorks(dest, 'main')
+  })
+
+  it('bare-root repo → hub layout', async () => {
+    const src = makeTempDir()
+    await makeBareRootRepo(src)
+    const config = await detect(src)
+    expect(config.type).toBe('bare-root')
+    const dest = src + '-hub'
+
+    await migrate(config, { source: src, dest })
+
+    await assertHubStructure(dest)
+  })
+
+  it('bare-hub repo → new location', async () => {
+    const src = makeTempDir()
+    await makeBareHubRepo(src)
+    const config = await detect(src)
+    expect(config.type).toBe('bare-hub')
+    const dest2 = src + '-hub2'
+
+    await migrate(config, { source: src, dest: dest2 })
+
+    await assertHubStructure(dest2)
+  })
+
+  it('branch with / → sanitized to - in directory name', async () => {
+    const src = makeTempDir()
+    await makeStandardRepo(src, ['feature/my-feature'])
+    const config = await detect(src)
+    const dest = src + '-hub'
+
+    await migrate(config, { source: src, dest })
+
+    await assertHubStructure(dest)
+    await assertWorktreeWorks(dest, 'main')
+    await assertWorktreeWorks(dest, 'feature/my-feature')
+    // The directory should be named feature-my-feature
+    expect(existsSync(join(dest, 'feature-my-feature'))).toBe(true)
+  })
+
+  it('branch name collision → throws with collision message', async () => {
+    const src = makeTempDir()
+    // Create a standard repo with two branches that sanitize to the same name:
+    // 'a/b' → 'a-b' and 'a-b' → 'a-b'
+    // We use different worktree directory names to avoid the filesystem conflict.
+    await $`git init ${src}`.quiet()
+    await $`git -C ${src} config user.email "test@test.com"`.quiet()
+    await $`git -C ${src} config user.name "Test"`.quiet()
+    await $`git -C ${src} commit --allow-empty -m "init"`.quiet()
+    // Create first worktree with branch 'a/b' in dir 'wt1'
+    const wt1 = join(src + '-wt1')
+    await $`git -C ${src} worktree add -b ${'a/b'} ${wt1}`.quiet()
+    // Create second worktree with branch 'a-b' in dir 'wt2'
+    const wt2 = join(src + '-wt2')
+    await $`git -C ${src} worktree add -b ${'a-b'} ${wt2}`.quiet()
+
+    const config = await detect(src)
+    const dest = src + '-hub'
+
+    await expect(migrate(config, { source: src, dest })).rejects.toThrow('collision')
+  })
+
+  it('default dest derivation when dest is empty string', async () => {
+    const src = makeTempDir()
+    await makeStandardRepo(src)
+    const config = await detect(src)
+
+    const result = await migrate(config, { source: src, dest: '' })
+
+    const expectedDest = join(dirname(src), basename(src) + '-bare')
+    expect(result).toBe(expectedDest)
+    await assertHubStructure(expectedDest)
+  })
+
+  it('throws if dest/.bare already exists', async () => {
+    const src = makeTempDir()
+    await makeStandardRepo(src)
+    const config = await detect(src)
+    const dest = src + '-hub'
+    await makeBareHubRepo(dest)  // creates dest/.bare already
+
+    await expect(migrate(config, { source: src, dest })).rejects.toThrow('already exists')
+  })
+})

package/test/security.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest'
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { detect } from '../src/detect.ts'
+
+describe('security', () => {
+  it('detect() rejects a .git file pointing to a non-git directory (path traversal guard)', async () => {
+    // Simulates a malicious repo whose .git file points at an arbitrary
+    // directory (e.g. ~/.ssh) rather than a real git object store.
+    // A secure detect() must throw rather than return that path as config.gitdir,
+    // preventing migrate() from cp -a'ing the sensitive directory into dest/.bare/.
+
+    // --- Step 1: Create the "sensitive" directory (plain dir, not a git repo) ---
+    const sensitiveDir = mkdtempSync(join(tmpdir(), 'git-wto-sensitive-'))
+    writeFileSync(join(sensitiveDir, 'secret.txt'), 'sensitive data')
+
+    // --- Step 2: Create a malicious repo with .git pointing at the sensitive dir ---
+    const maliciousRepo = mkdtempSync(join(tmpdir(), 'git-wto-malicious-'))
+    writeFileSync(join(maliciousRepo, '.git'), `gitdir: ${sensitiveDir}\n`)
+
+    // --- Step 3: detect() must throw — the gitdir is not a git object store ---
+    await expect(detect(maliciousRepo)).rejects.toThrow('gitdir does not appear to be a git repository')
+  })
+})

package/test/worktrees.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest'
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { $ } from 'bun'
+import { parsePorcelain, listWorktrees } from '../src/worktrees'
+
+describe('parsePorcelain', () => {
+  it('parses a single normal worktree with branch main', () => {
+    const input = `worktree /path/to/main
+HEAD abc123def456abc123def456abc123def456abc123
+branch refs/heads/main
+`
+    const result = parsePorcelain(input)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      path: '/path/to/main',
+      head: 'abc123def456abc123def456abc123def456abc123',
+      branch: 'main',
+      isBare: false,
+    })
+  })
+
+  it('parses multiple worktrees (main + feature branch)', () => {
+    const input = `worktree /path/to/main
+HEAD abc123def456abc123def456abc123def456abc123
+branch refs/heads/main
+
+worktree /path/to/feature
+HEAD def456abc123def456abc123def456abc123def456
+branch refs/heads/feature
+`
+    const result = parsePorcelain(input)
+    expect(result).toHaveLength(2)
+    expect(result[0]).toEqual({
+      path: '/path/to/main',
+      head: 'abc123def456abc123def456abc123def456abc123',
+      branch: 'main',
+      isBare: false,
+    })
+    expect(result[1]).toEqual({
+      path: '/path/to/feature',
+      head: 'def456abc123def456abc123def456abc123def456',
+      branch: 'feature',
+      isBare: false,
+    })
+  })
+
+  it('parses a worktree with detached HEAD (branch = null, isBare = false)', () => {
+    const input = `worktree /path/to/detached
+HEAD ghi789abc123ghi789abc123ghi789abc123ghi789
+detached
+`
+    const result = parsePorcelain(input)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      path: '/path/to/detached',
+      head: 'ghi789abc123ghi789abc123ghi789abc123ghi789',
+      branch: null,
+      isBare: false,
+    })
+  })
+
+  it('parses a bare worktree (isBare = true, branch = null)', () => {
+    const input = `worktree /path/to/bare
+HEAD 0000000000000000000000000000000000000000
+bare
+`
+    const result = parsePorcelain(input)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      path: '/path/to/bare',
+      head: '0000000000000000000000000000000000000000',
+      branch: null,
+      isBare: true,
+    })
+  })
+
+  it('parses a branch with / in name (feature/my-feature)', () => {
+    const input = `worktree /path/to/feature
+HEAD abc123def456abc123def456abc123def456abc123
+branch refs/heads/feature/my-feature
+`
+    const result = parsePorcelain(input)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      path: '/path/to/feature',
+      head: 'abc123def456abc123def456abc123def456abc123',
+      branch: 'feature/my-feature',
+      isBare: false,
+    })
+  })
+
+  it('parses mixed: bare + linked + detached', () => {
+    const input = `worktree /path/to/bare
+HEAD 0000000000000000000000000000000000000000
+bare
+
+worktree /path/to/linked
+HEAD abc123def456abc123def456abc123def456abc123
+branch refs/heads/main
+
+worktree /path/to/detached
+HEAD def456abc123def456abc123def456abc123def456
+detached
+`
+    const result = parsePorcelain(input)
+    expect(result).toHaveLength(3)
+    expect(result[0]).toEqual({
+      path: '/path/to/bare',
+      head: '0000000000000000000000000000000000000000',
+      branch: null,
+      isBare: true,
+    })
+    expect(result[1]).toEqual({
+      path: '/path/to/linked',
+      head: 'abc123def456abc123def456abc123def456abc123',
+      branch: 'main',
+      isBare: false,
+    })
+    expect(result[2]).toEqual({
+      path: '/path/to/detached',
+      head: 'def456abc123def456abc123def456abc123def456',
+      branch: null,
+      isBare: false,
+    })
+  })
+})
+
+describe('listWorktrees', () => {
+  it('lists worktrees from a real git repo', async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'git-worktree-test-'))
+    const repoDir = join(tmpDir, 'repo')
+    const linkedDir = join(tmpDir, 'linked')
+
+    // Initialize a git repo with an initial commit
+    await $`git init ${repoDir}`.quiet()
+    await $`git -C ${repoDir} config user.email test@example.com`.quiet()
+    await $`git -C ${repoDir} config user.name Test`.quiet()
+    await $`touch ${join(repoDir, 'README')}`.quiet()
+    await $`git -C ${repoDir} add README`.quiet()
+    await $`git -C ${repoDir} commit -m init`.quiet()
+
+    // Add a linked worktree on a new branch
+    await $`git -C ${repoDir} worktree add -b feature ${linkedDir}`.quiet()
+
+    const worktrees = await listWorktrees(repoDir)
+
+    expect(worktrees.length).toBe(2)
+
+    const main = worktrees.find(w => w.path === repoDir)
+    expect(main).toBeDefined()
+    // branch name depends on system git default (master or main)
+    expect(typeof main!.branch).toBe('string')
+    expect(main!.isBare).toBe(false)
+    expect(main!.head).toMatch(/^[0-9a-f]{40}$/)
+
+    const linked = worktrees.find(w => w.path === linkedDir)
+    expect(linked).toBeDefined()
+    expect(linked!.branch).toBe('feature')
+    expect(linked!.isBare).toBe(false)
+    expect(linked!.head).toMatch(/^[0-9a-f]{40}$/)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": ["bun-types"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "test/**/*"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config'
+import { resolve } from 'node:path'
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      bun: resolve(__dirname, 'test/__bun-shim__.ts'),
+    },
+  },
+  test: {
+    globals: false,
+  },
+})