git-worktree-organize 1.0.9 → 1.0.10

package/test/helpers/repo.ts

@@ -1,75 +0,0 @@
-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()
-}

package/test/migrate.test.ts

@@ -1,124 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,13 +0,0 @@
-{
-  "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

@@ -1,13 +0,0 @@
-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,
-  },
-})