chapterhouse 0.3.12 → 0.3.14

package/dist/squad/worktree.js

@@ -1,295 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join, relative } from 'node:path';
-// ---------------------------------------------------------------------------
-// Path convention
-// ---------------------------------------------------------------------------
-/**
- * Location: `.worktrees/{agent}-{issueNum}/` inside the repo root.
- * This keeps worktrees discoverable (they're adjacent to the code) and
- * `git worktree list` always surfaces them. The directory is gitignored.
- *
- * Tradeoff vs `~/.cache/chapterhouse-worktrees/<repo>/`:
- *   + Visible without knowing a cache path
- *   + `chapterhouse squad worktree list` doesn't need to guess the home
- *   - Must be added to .gitignore (done once, documented here)
- */
-export function getWorktreePath(repoRoot, agent, issueNum) {
-    return join(repoRoot, '.worktrees', `${agent}-${issueNum}`);
-}
-export function getBranchName(issueNum, slug) {
-    const safeslug = slug ? `-${slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')}` : '';
-    return `squad/${issueNum}${safeslug}`;
-}
-// ---------------------------------------------------------------------------
-// Git helpers
-// ---------------------------------------------------------------------------
-function git(args, cwd) {
-    const result = spawnSync('git', args, { cwd, encoding: 'utf-8' });
-    return {
-        ok: result.status === 0,
-        stdout: (result.stdout ?? '').trim(),
-        stderr: (result.stderr ?? '').trim(),
-    };
-}
-function hasUncommittedChanges(worktreePath) {
-    const r = git(['status', '--porcelain'], worktreePath);
-    return r.ok && r.stdout.length > 0;
-}
-function isBranchMerged(repoRoot, branch, base = 'main') {
-    // merged if branch tip is reachable from base
-    const r = git(['branch', '--merged', base, '--list', branch], repoRoot);
-    return r.ok && r.stdout.length > 0;
-}
-function getRepoRoot(cwd) {
-    const r = git(['rev-parse', '--show-toplevel'], cwd);
-    if (!r.ok)
-        throw new Error(`Not inside a git repo: ${r.stderr}`);
-    return r.stdout;
-}
-/**
- * Create a dedicated worktree for an agent + issue pair.
- * Branch: `squad/{issueNum}-{agent}` (off `main` by default).
- * Returns the worktree path.
- */
-export function createWorktree(repoRoot, agent, issueNum, opts = {}) {
-    const baseBranch = opts.baseBranch ?? 'main';
-    const branch = getBranchName(issueNum, opts.slug ?? agent);
-    const worktreePath = getWorktreePath(repoRoot, agent, issueNum);
-    if (existsSync(worktreePath)) {
-        // Reuse existing worktree
-        console.log(`↩  Reusing existing worktree: ${relative(repoRoot, worktreePath)}`);
-        return worktreePath;
-    }
-    // Check if branch already exists (another agent on same issue)
-    const branchExists = git(['show-ref', '--verify', `refs/heads/${branch}`], repoRoot);
-    let result;
-    if (branchExists.ok) {
-        result = git(['worktree', 'add', worktreePath, branch], repoRoot);
-    }
-    else {
-        result = git(['worktree', 'add', '-b', branch, worktreePath, baseBranch], repoRoot);
-    }
-    if (!result.ok) {
-        throw new Error(`Failed to create worktree: ${result.stderr}`);
-    }
-    console.log(`✅ Worktree created: ${relative(repoRoot, worktreePath)} (branch: ${branch})`);
-    return worktreePath;
-}
-/**
- * List all squad worktrees (worktrees under `.worktrees/` with `squad/` branches).
- */
-export function listWorktrees(repoRoot) {
-    const r = git(['worktree', 'list', '--porcelain'], repoRoot);
-    if (!r.ok)
-        throw new Error(`git worktree list failed: ${r.stderr}`);
-    const entries = parseWorktreePorcelain(r.stdout);
-    const squadEntries = entries.filter(e => e.path.includes('/.worktrees/'));
-    return squadEntries.map(e => {
-        const dirName = e.path.split('/.worktrees/')[1] ?? '';
-        const match = dirName.match(/^([^-]+)-(\d+)/);
-        const agent = match ? match[1] : dirName;
-        const issueNum = match ? match[2] : '?';
-        const dirty = existsSync(e.path) && hasUncommittedChanges(e.path);
-        return {
-            agent,
-            issueNum,
-            path: e.path,
-            branch: e.branch ?? '(detached)',
-            exists: existsSync(e.path),
-            dirty,
-            head: e.head ?? '',
-        };
-    });
-}
-/**
- * Remove a specific worktree. Warns but refuses if the worktree has
- * uncommitted changes (pass `force: true` to override).
- */
-export function removeWorktree(repoRoot, agent, issueNum, opts = {}) {
-    const worktreePath = getWorktreePath(repoRoot, agent, issueNum);
-    if (!existsSync(worktreePath)) {
-        console.log(`ℹ  Worktree not found: ${worktreePath} (nothing to remove)`);
-        return;
-    }
-    if (!opts.force && hasUncommittedChanges(worktreePath)) {
-        console.error(`⚠  Worktree ${relative(repoRoot, worktreePath)} has uncommitted changes.\n` +
-            `   Commit or stash your work before removing, or pass --force to discard.`);
-        process.exitCode = 1;
-        return;
-    }
-    const removeArgs = ['worktree', 'remove', worktreePath];
-    if (opts.force)
-        removeArgs.push('--force');
-    const r = git(removeArgs, repoRoot);
-    if (!r.ok)
-        throw new Error(`Failed to remove worktree: ${r.stderr}`);
-    if (opts.deleteBranch) {
-        const branch = getBranchName(issueNum, agent);
-        const del = git(['branch', '-d', branch], repoRoot);
-        if (!del.ok) {
-            console.warn(`⚠  Could not delete branch ${branch}: ${del.stderr}`);
-        }
-    }
-    console.log(`🗑  Removed worktree: ${relative(repoRoot, worktreePath)}`);
-}
-/**
- * Remove all squad worktrees whose branch has been merged into `main`.
- * Warns and skips worktrees with uncommitted changes.
- */
-export function pruneWorktrees(repoRoot, opts = {}) {
-    const base = opts.base ?? 'main';
-    const worktrees = listWorktrees(repoRoot);
-    if (worktrees.length === 0) {
-        console.log('ℹ  No squad worktrees found.');
-        return;
-    }
-    for (const wt of worktrees) {
-        const merged = isBranchMerged(repoRoot, wt.branch, base);
-        if (!merged) {
-            console.log(`↷  Skipping ${wt.agent}-${wt.issueNum} (branch not merged into ${base})`);
-            continue;
-        }
-        if (wt.dirty) {
-            console.warn(`⚠  Skipping ${wt.agent}-${wt.issueNum} (has uncommitted changes — clean up manually)`);
-            continue;
-        }
-        if (opts.dryRun) {
-            console.log(`[dry-run] Would remove: ${wt.agent}-${wt.issueNum} (branch: ${wt.branch})`);
-            continue;
-        }
-        removeWorktree(repoRoot, wt.agent, Number(wt.issueNum), { deleteBranch: true });
-    }
-}
-// ---------------------------------------------------------------------------
-// Print helpers
-// ---------------------------------------------------------------------------
-export function printWorktreeList(repoRoot) {
-    const worktrees = listWorktrees(repoRoot);
-    if (worktrees.length === 0) {
-        console.log('No squad worktrees found.');
-        return;
-    }
-    const header = ['AGENT', 'ISSUE', 'BRANCH', 'STATUS', 'PATH'];
-    const rows = worktrees.map(wt => [
-        wt.agent,
-        wt.issueNum,
-        wt.branch,
-        wt.dirty ? '⚠ dirty' : '✓ clean',
-        wt.path,
-    ]);
-    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(r => r[i].length)));
-    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join('  ');
-    console.log(fmt(header));
-    console.log(widths.map(w => '-'.repeat(w)).join('  '));
-    for (const row of rows)
-        console.log(fmt(row));
-}
-export function printWorktreeHelp() {
-    console.log(`
-chapterhouse squad worktree — manage per-agent git worktrees
-
-Usage:
-  chapterhouse squad worktree <subcommand>
-
-Subcommands:
-  create <agent> <issue> [--base <branch>] [--slug <slug>]
-      Create a dedicated worktree for an agent + issue.
-      Path: .worktrees/{agent}-{issue}/   Branch: squad/{issue}-{agent}
-
-  list
-      List all squad worktrees with agent, branch, and status.
-
-  remove <agent> <issue> [--force] [--delete-branch]
-      Remove a worktree. Refuses if there are uncommitted changes
-      unless --force is passed (which discards the changes).
-
-  prune [--base <branch>] [--dry-run]
-      Remove all worktrees whose branch has been merged into main
-      (or the specified --base branch). Skips dirty worktrees.
-`.trim());
-}
-function parseWorktreePorcelain(output) {
-    const entries = [];
-    let current = null;
-    for (const line of output.split('\n')) {
-        if (line.startsWith('worktree ')) {
-            if (current?.path)
-                entries.push(current);
-            current = { path: line.slice('worktree '.length) };
-        }
-        else if (line.startsWith('HEAD ') && current) {
-            current.head = line.slice('HEAD '.length);
-        }
-        else if (line.startsWith('branch ') && current) {
-            current.branch = line.slice('branch refs/heads/'.length);
-        }
-        else if (line === '' && current?.path) {
-            entries.push(current);
-            current = null;
-        }
-    }
-    if (current?.path)
-        entries.push(current);
-    return entries;
-}
-// ---------------------------------------------------------------------------
-// CLI entry point
-// ---------------------------------------------------------------------------
-export async function runWorktreeCli(args) {
-    let repoRoot;
-    try {
-        repoRoot = getRepoRoot(process.cwd());
-    }
-    catch {
-        console.error('❌ Not inside a git repository.');
-        process.exit(1);
-    }
-    const subcommand = args[0];
-    switch (subcommand) {
-        case 'create': {
-            const agent = args[1];
-            const issueNum = args[2];
-            if (!agent || !issueNum) {
-                console.error('Usage: chapterhouse squad worktree create <agent> <issue> [--base <branch>] [--slug <slug>]');
-                process.exit(1);
-            }
-            const baseIdx = args.indexOf('--base');
-            const baseBranch = baseIdx !== -1 ? args[baseIdx + 1] : undefined;
-            const slugIdx = args.indexOf('--slug');
-            const slug = slugIdx !== -1 ? args[slugIdx + 1] : undefined;
-            const path = createWorktree(repoRoot, agent, issueNum, { baseBranch, slug });
-            console.log(path);
-            break;
-        }
-        case 'list':
-            printWorktreeList(repoRoot);
-            break;
-        case 'remove': {
-            const agent = args[1];
-            const issueNum = args[2];
-            if (!agent || !issueNum) {
-                console.error('Usage: chapterhouse squad worktree remove <agent> <issue> [--force] [--delete-branch]');
-                process.exit(1);
-            }
-            removeWorktree(repoRoot, agent, issueNum, {
-                force: args.includes('--force'),
-                deleteBranch: args.includes('--delete-branch'),
-            });
-            break;
-        }
-        case 'prune': {
-            const baseIdx = args.indexOf('--base');
-            const base = baseIdx !== -1 ? args[baseIdx + 1] : undefined;
-            pruneWorktrees(repoRoot, { base, dryRun: args.includes('--dry-run') });
-            break;
-        }
-        default:
-            if (subcommand)
-                console.error(`Unknown worktree subcommand: ${subcommand}\n`);
-            printWorktreeHelp();
-            if (subcommand)
-                process.exit(1);
-    }
-}
-//# sourceMappingURL=worktree.js.map

package/dist/squad/worktree.test.js

@@ -1,189 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
-import test from 'node:test';
-// ---------------------------------------------------------------------------
-// Test fixture: minimal git repo
-// ---------------------------------------------------------------------------
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, '.test-work', `worktree-${process.pid}`);
-function initRepo(dir) {
-    mkdirSync(dir, { recursive: true });
-    // --initial-branch=main ensures the branch is named 'main' regardless of
-    // the runner's global init.defaultBranch setting (older git may default to 'master').
-    execSync('git init --initial-branch=main', { cwd: dir, stdio: 'pipe' });
-    execSync('git config user.email "test@example.com"', { cwd: dir, stdio: 'pipe' });
-    execSync('git config user.name "Test CI"', { cwd: dir, stdio: 'pipe' });
-    writeFileSync(join(dir, 'README.md'), '# test\n');
-    execSync('git add .', { cwd: dir, stdio: 'pipe' });
-    // An initial commit is required so that 'main' resolves as a ref.
-    // Without it, `git worktree add <path> -b <branch> main` fails with
-    // "fatal: invalid reference: main" because the branch has no commits.
-    execSync('git commit -m "chore: initial commit"', { cwd: dir, stdio: 'pipe' });
-}
-// We need a separate repo because the main repo's worktrees would interfere.
-// Each test suite gets its own isolated sandbox git repo.
-const testRepo = join(sandboxRoot, 'repo');
-test.before(() => {
-    mkdirSync(sandboxRoot, { recursive: true });
-    initRepo(testRepo);
-});
-test.after(() => {
-    // Clean up any worktrees first (git worktree remove) then the sandbox
-    try {
-        execSync('git worktree prune', { cwd: testRepo });
-    }
-    catch { /* ignore */ }
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-async function loadWorktree() {
-    return await import(new URL(`./worktree.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-// ---------------------------------------------------------------------------
-// getWorktreePath
-// ---------------------------------------------------------------------------
-test('getWorktreePath returns correct path inside .worktrees/', async () => {
-    const m = await loadWorktree();
-    const result = m.getWorktreePath('/repo', 'kaylee', 42);
-    assert.equal(result, '/repo/.worktrees/kaylee-42');
-});
-test('getWorktreePath works with string issue number', async () => {
-    const m = await loadWorktree();
-    const result = m.getWorktreePath('/repo', 'wash', '17');
-    assert.equal(result, '/repo/.worktrees/wash-17');
-});
-// ---------------------------------------------------------------------------
-// getBranchName
-// ---------------------------------------------------------------------------
-test('getBranchName without slug uses squad/{issue} format', async () => {
-    const m = await loadWorktree();
-    assert.equal(m.getBranchName(49), 'squad/49');
-});
-test('getBranchName with slug appends kebab-case slug', async () => {
-    const m = await loadWorktree();
-    assert.equal(m.getBranchName(49, 'git worktrees'), 'squad/49-git-worktrees');
-});
-test('getBranchName normalises special characters in slug', async () => {
-    const m = await loadWorktree();
-    assert.equal(m.getBranchName(10, 'Fix Login!!'), 'squad/10-fix-login');
-});
-// ---------------------------------------------------------------------------
-// createWorktree
-// ---------------------------------------------------------------------------
-test('createWorktree creates a worktree at .worktrees/{agent}-{issue}/', async () => {
-    const m = await loadWorktree();
-    const { existsSync } = await import('node:fs');
-    const wt = m.createWorktree(testRepo, 'kaylee', 1);
-    assert.ok(existsSync(wt), `Worktree path should exist: ${wt}`);
-    assert.ok(wt.endsWith('.worktrees/kaylee-1'), `Path should end with .worktrees/kaylee-1, got: ${wt}`);
-    // Verify branch was created
-    const { spawnSync } = await import('node:child_process');
-    const r = spawnSync('git', ['branch', '--list', 'squad/1-kaylee'], { cwd: testRepo, encoding: 'utf-8' });
-    assert.ok(r.stdout.trim().length > 0, 'Branch squad/1-kaylee should exist');
-});
-test('createWorktree reuses existing worktree without error', async () => {
-    const m = await loadWorktree();
-    // create again (already exists from above)
-    assert.doesNotThrow(() => {
-        m.createWorktree(testRepo, 'kaylee', 1);
-    });
-});
-test('createWorktree respects --base option', async () => {
-    const m = await loadWorktree();
-    const { existsSync } = await import('node:fs');
-    // We guarantee 'main' exists via --initial-branch=main in initRepo
-    const wt = m.createWorktree(testRepo, 'wash', 2, { baseBranch: 'main' });
-    assert.ok(existsSync(wt), `Worktree should be created at ${wt}`);
-});
-test('createWorktree with slug uses slug in branch name', async () => {
-    const m = await loadWorktree();
-    const wt = m.createWorktree(testRepo, 'zoe', 3, { slug: 'test-isolation' });
-    const { spawnSync } = await import('node:child_process');
-    const r = spawnSync('git', ['branch', '--list', 'squad/3-test-isolation'], { cwd: testRepo, encoding: 'utf-8' });
-    assert.ok(r.stdout.trim().length > 0, 'Branch squad/3-test-isolation should exist');
-    void wt;
-});
-// ---------------------------------------------------------------------------
-// listWorktrees
-// ---------------------------------------------------------------------------
-test('listWorktrees returns entries for squad worktrees', async () => {
-    const m = await loadWorktree();
-    const list = m.listWorktrees(testRepo);
-    // We created kaylee-1 above; at minimum it should appear
-    assert.ok(list.length >= 1, 'Should have at least 1 squad worktree');
-    const kaylee = list.find(w => w.agent === 'kaylee' && w.issueNum === '1');
-    assert.ok(kaylee, 'Should include kaylee-1 worktree');
-    assert.equal(kaylee?.branch, 'squad/1-kaylee');
-    assert.equal(typeof kaylee?.dirty, 'boolean');
-});
-test('listWorktrees does not include the main checkout', async () => {
-    const m = await loadWorktree();
-    const list = m.listWorktrees(testRepo);
-    const hasMain = list.some(w => !w.path.includes('/.worktrees/'));
-    assert.ok(!hasMain, 'Main checkout should not appear in squad worktree list');
-});
-// ---------------------------------------------------------------------------
-// removeWorktree
-// ---------------------------------------------------------------------------
-test('removeWorktree removes a clean worktree', async () => {
-    const m = await loadWorktree();
-    // Create a fresh worktree to remove
-    m.createWorktree(testRepo, 'scribe', 5);
-    const wtPath = m.getWorktreePath(testRepo, 'scribe', 5);
-    const { existsSync } = await import('node:fs');
-    assert.ok(existsSync(wtPath));
-    m.removeWorktree(testRepo, 'scribe', 5);
-    assert.ok(!existsSync(wtPath), 'Worktree should be removed');
-});
-test('removeWorktree is a no-op for non-existent worktree', async () => {
-    const m = await loadWorktree();
-    assert.doesNotThrow(() => {
-        m.removeWorktree(testRepo, 'ghost', 999);
-    });
-});
-test('removeWorktree refuses to remove dirty worktree without --force', async () => {
-    const m = await loadWorktree();
-    const { writeFileSync } = await import('node:fs');
-    // Create worktree, then add an uncommitted file
-    m.createWorktree(testRepo, 'mal', 6);
-    const wtPath = m.getWorktreePath(testRepo, 'mal', 6);
-    writeFileSync(join(wtPath, 'uncommitted.txt'), 'dirty\n');
-    // Should set exitCode=1 but not throw
-    const prev = process.exitCode;
-    process.exitCode = 0;
-    m.removeWorktree(testRepo, 'mal', 6, { force: false });
-    const rejected = process.exitCode === 1;
-    process.exitCode = prev; // restore
-    assert.ok(rejected, 'Should set exitCode=1 for dirty worktree');
-    // cleanup with force
-    m.removeWorktree(testRepo, 'mal', 6, { force: true });
-});
-// ---------------------------------------------------------------------------
-// pruneWorktrees
-// ---------------------------------------------------------------------------
-test('pruneWorktrees dry-run lists worktrees that would be removed', async () => {
-    const m = await loadWorktree();
-    // Capture stdout (basic test — just ensure it doesn't throw)
-    assert.doesNotThrow(() => {
-        m.pruneWorktrees(testRepo, { dryRun: true });
-    });
-});
-test('pruneWorktrees skips worktrees on unmerged branches', async () => {
-    const m = await loadWorktree();
-    const { existsSync, writeFileSync } = await import('node:fs');
-    const { spawnSync } = await import('node:child_process');
-    const { join } = await import('node:path');
-    // zoe-3 worktree should exist (created in earlier test)
-    const wt = m.getWorktreePath(testRepo, 'zoe', 3);
-    assert.ok(existsSync(wt), 'zoe-3 worktree should exist');
-    // Add a commit so the branch diverges from base — otherwise git considers
-    // a branch with no extra commits as already merged into its parent.
-    writeFileSync(join(wt, 'feature.txt'), 'in progress\n');
-    spawnSync('git', ['add', 'feature.txt'], { cwd: wt, stdio: 'pipe' });
-    spawnSync('git', ['commit', '-m', 'feat: in-progress work'], { cwd: wt, stdio: 'pipe' });
-    // We guarantee 'main' via --initial-branch=main in initRepo
-    m.pruneWorktrees(testRepo, { base: 'main' });
-    assert.ok(existsSync(wt), 'Unmerged worktree should NOT be pruned');
-});
-//# sourceMappingURL=worktree.test.js.map