xtrm-cli 0.5.0

package/test/atomic-config.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import { deepMergeWithProtection } from '../src/utils/atomic-config.js';
+
+describe('deepMergeWithProtection (hooks merge behavior)', () => {
+    it('upgrades matcher tokens for same hook command without duplicating hook', () => {
+        const local = {
+            hooks: {
+                PostToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit',
+                    hooks: [{ command: 'python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/quality-check.py"' }],
+                }],
+            },
+        };
+
+        const incoming = {
+            hooks: {
+                PostToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol',
+                    hooks: [{ command: 'python3 "$CLAUDE_PROJECT_DIR/hooks/quality-check.py"' }],
+                }],
+            },
+        };
+
+        const merged = deepMergeWithProtection(local, incoming);
+        const wrappers = merged.hooks.PostToolUse;
+        expect(wrappers).toHaveLength(1);
+        expect(wrappers[0].matcher).toContain('mcp__serena__insert_after_symbol');
+        expect(wrappers[0].matcher).toContain('mcp__serena__insert_before_symbol');
+        expect(wrappers[0].matcher).toContain('mcp__serena__rename_symbol');
+        expect(wrappers[0].matcher).toContain('mcp__serena__replace_symbol_body');
+        expect(wrappers[0].hooks).toHaveLength(1);
+    });
+
+    it('preserves local custom hooks and still installs incoming wrappers', () => {
+        const local = {
+            hooks: {
+                PreToolUse: [{
+                    matcher: 'Write',
+                    hooks: [{ command: 'node /custom/local-hook.mjs' }],
+                }],
+            },
+        };
+
+        const incoming = {
+            hooks: {
+                PreToolUse: [{
+                    matcher: 'Edit',
+                    hooks: [{ command: 'node /repo/hooks/main-guard.mjs' }],
+                }],
+                PostToolUse: [{
+                    matcher: 'Edit',
+                    hooks: [{ command: 'node /repo/hooks/main-guard-post-push.mjs' }],
+                }],
+            },
+        };
+
+        const merged = deepMergeWithProtection(local, incoming);
+        expect(merged.hooks.PreToolUse).toHaveLength(2);
+        expect(merged.hooks.PreToolUse[0].hooks[0].command).toBe('node /custom/local-hook.mjs');
+        expect(merged.hooks.PreToolUse[1].hooks[0].command).toBe('node /repo/hooks/main-guard.mjs');
+        expect(merged.hooks.PostToolUse).toHaveLength(1);
+    });
+
+    it('keeps protected non-hook keys unchanged', () => {
+        const local = {
+            model: 'claude-sonnet',
+            hooks: {
+                SessionStart: [{ hooks: [{ command: 'echo start-local' }] }],
+            },
+        };
+
+        const incoming = {
+            model: 'claude-opus',
+            hooks: {
+                SessionStart: [{ hooks: [{ command: 'echo start-repo' }] }],
+            },
+        };
+
+        const merged = deepMergeWithProtection(local, incoming);
+        expect(merged.model).toBe('claude-sonnet');
+        expect(merged.hooks.SessionStart).toHaveLength(2);
+    });
+});
+
+
+describe('deepMergeWithProtection (hooks merge behavior) — matcher dedup', () => {
+    it('keeps two same-script entries separate when their matchers are disjoint', () => {
+        // Simulates config/hooks.json having main-guard wired for write-tools
+        // AND separately for Bash — they must not be merged into one entry
+        const local = {
+            hooks: {
+                PreToolUse: [] as any[],
+            },
+        };
+        const incoming = {
+            hooks: {
+                PreToolUse: [
+                    {
+                        matcher: 'Write|Edit|MultiEdit',
+                        hooks: [{ command: 'node "/hooks/main-guard.mjs"', timeout: 5000 }],
+                    },
+                    {
+                        matcher: 'Bash',
+                        hooks: [{ command: 'node "/hooks/main-guard.mjs"', timeout: 5000 }],
+                    },
+                ],
+            },
+        };
+        const merged = deepMergeWithProtection(local, incoming);
+        const wrappers = merged.hooks.PreToolUse;
+        expect(wrappers).toHaveLength(2);
+        expect(wrappers[0].matcher).toBe('Write|Edit|MultiEdit');
+        expect(wrappers[1].matcher).toBe('Bash');
+    });
+
+    it('still upgrades matcher when entries share at least one common token', () => {
+        const local = {
+            hooks: {
+                PreToolUse: [{
+                    matcher: 'Write|Edit',
+                    hooks: [{ command: 'node "/hooks/main-guard.mjs"' }],
+                }],
+            },
+        };
+        const incoming = {
+            hooks: {
+                PreToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit',
+                    hooks: [{ command: 'node "/hooks/main-guard.mjs"' }],
+                }],
+            },
+        };
+        const merged = deepMergeWithProtection(local, incoming);
+        const wrappers = merged.hooks.PreToolUse;
+        expect(wrappers).toHaveLength(1);
+        expect(wrappers[0].matcher).toContain('MultiEdit');
+    });
+});

package/test/clean.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.join(__dirname, '../..');
+const CLI_ENTRY = path.join(__dirname, '../src/index.ts');
+
+const CLI_BIN = path.join(__dirname, '../dist/index.cjs');
+
+function runClean(
+  args: string[],
+  env: Record<string, string> = {},
+): { stdout: string; stderr: string; status: number } {
+  const r = spawnSync('node', [CLI_BIN, 'clean', ...args], {
+    encoding: 'utf8',
+    cwd: REPO_ROOT,
+    env: { ...process.env, ...env },
+    timeout: 30000,
+  });
+  return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', status: r.status ?? -1 };
+}
+
+// ── canonical wiring validation ─────────────────────────────────────────────
+
+describe('xtrm clean — canonical wiring validation', () => {
+  it('reports stale event: serena-workflow-reminder.py wired to PreToolUse is removed', () => {
+    const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'xtrm-clean-test-'));
+    const hooksDir = path.join(tmpHome, '.claude', 'hooks');
+    mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+    mkdirSync(hooksDir, { recursive: true });
+
+    // Stub hook file so cleanHooks doesn't also flag it as orphaned
+    writeFileSync(path.join(hooksDir, 'serena-workflow-reminder.py'), '# stub');
+
+    writeFileSync(path.join(tmpHome, '.claude', 'settings.json'), JSON.stringify({
+      hooks: {
+        SessionStart: [
+          { hooks: [{ type: 'command', command: `python3 "${path.join(hooksDir, 'serena-workflow-reminder.py')}"` }] },
+        ],
+        // Stale: serena-workflow-reminder.py is NOT in PreToolUse in config/hooks.json
+        PreToolUse: [
+          {
+            matcher: 'Read|Edit|mcp__serena__rename_symbol',
+            hooks: [{ type: 'command', command: `python3 "${path.join(hooksDir, 'serena-workflow-reminder.py')}"` }],
+          },
+        ],
+      },
+    }, null, 2));
+
+    try {
+      const r = runClean(['--dry-run', '--hooks-only'], { HOME: tmpHome });
+      expect(r.stdout, `stdout:\n${r.stdout}\nstderr:\n${r.stderr}`).toMatch(
+        /serena-workflow-reminder\.py.*stale wiring/i,
+      );
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  it('reports stale matcher: gitnexus-hook.cjs with Read|Grep|Glob prefix is removed', () => {
+    const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'xtrm-clean-test-'));
+    const hooksDir = path.join(tmpHome, '.claude', 'hooks');
+    mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+    mkdirSync(path.join(hooksDir, 'gitnexus'), { recursive: true });
+    writeFileSync(path.join(hooksDir, 'gitnexus', 'gitnexus-hook.cjs'), '// stub');
+
+    writeFileSync(path.join(tmpHome, '.claude', 'settings.json'), JSON.stringify({
+      hooks: {
+        PostToolUse: [
+          {
+            // Stale: canonical has Bash|mcp__serena__... (no Read|Grep|Glob)
+            matcher: 'Read|Grep|Glob|Bash|mcp__serena__find_symbol|mcp__serena__get_symbols_overview',
+            hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'gitnexus/gitnexus-hook.cjs')}"`, timeout: 10000 }],
+          },
+        ],
+      },
+    }, null, 2));
+
+    try {
+      const r = runClean(['--dry-run', '--hooks-only'], { HOME: tmpHome });
+      expect(r.stdout, `stdout:\n${r.stdout}\nstderr:\n${r.stderr}`).toMatch(
+        /gitnexus-hook\.cjs.*stale wiring/i,
+      );
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps branch-state.mjs as canonical (not flagged as orphaned)', () => {
+    const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'xtrm-clean-test-'));
+    const hooksDir = path.join(tmpHome, '.claude', 'hooks');
+    mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(path.join(hooksDir, 'branch-state.mjs'), '// stub');
+
+    writeFileSync(path.join(tmpHome, '.claude', 'settings.json'), JSON.stringify({
+      hooks: {
+        UserPromptSubmit: [
+          { hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'branch-state.mjs')}"`, timeout: 3000 }] },
+        ],
+      },
+    }, null, 2));
+
+    try {
+      const r = runClean(['--dry-run', '--hooks-only'], { HOME: tmpHome });
+      expect(r.stdout).toContain('No orphaned hook entries found');
+      expect(r.stdout).not.toContain('branch-state.mjs');
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps canonical entries that match config/hooks.json exactly', () => {
+    const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'xtrm-clean-test-'));
+    const hooksDir = path.join(tmpHome, '.claude', 'hooks');
+    mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(path.join(hooksDir, 'main-guard.mjs'), '// stub');
+
+    writeFileSync(path.join(tmpHome, '.claude', 'settings.json'), JSON.stringify({
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: 'Write|Edit|MultiEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol',
+            hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'main-guard.mjs')}"`, timeout: 5000 }],
+          },
+          {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'main-guard.mjs')}"`, timeout: 5000 }],
+          },
+        ],
+      },
+    }, null, 2));
+
+    try {
+      const r = runClean(['--dry-run', '--hooks-only'], { HOME: tmpHome });
+      expect(r.stdout).toContain('No orphaned hook entries found');
+      expect(r.stdout).not.toContain('main-guard.mjs');
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to script-only check and removes non-canonical scripts regardless', () => {
+    const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'xtrm-clean-test-'));
+    const hooksDir = path.join(tmpHome, '.claude', 'hooks');
+    mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+    mkdirSync(hooksDir, { recursive: true });
+
+    writeFileSync(path.join(tmpHome, '.claude', 'settings.json'), JSON.stringify({
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'some-old-hook.mjs')}"` }],
+          },
+        ],
+      },
+    }, null, 2));
+
+    try {
+      const r = runClean(['--dry-run', '--hooks-only'], { HOME: tmpHome });
+      expect(r.stdout).toContain('some-old-hook.mjs');
+    } finally {
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+});

package/test/config-schema.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const ROOT = resolve(__dirname, '..', '..');
+
+describe('config schema integrity', () => {
+    describe('cli/package.json bin field (in5e)', () => {
+        const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
+
+        it('has xtrm bin entry pointing to dist/index.cjs', () => {
+            expect(pkg.bin?.xtrm).toBe('./dist/index.cjs');
+        });
+
+        it('has xt bin entry pointing to dist/index.cjs', () => {
+            expect(pkg.bin?.xt).toBe('./dist/index.cjs');
+        });
+
+        it('both bin entries point to the same file', () => {
+            expect(pkg.bin?.xt).toBe(pkg.bin?.xtrm);
+        });
+    });
+
+    describe('config/pi/install-schema.json packages (m54d, x87v)', () => {
+        const schema = JSON.parse(readFileSync(resolve(ROOT, 'config', 'pi', 'install-schema.json'), 'utf8'));
+
+        it('contains npm:@robhowley/pi-structured-return', () => {
+            expect(schema.packages).toContain('npm:@robhowley/pi-structured-return');
+        });
+
+        it('does NOT contain npm:@aliou/pi-guardrails', () => {
+            expect(schema.packages).not.toContain('npm:@aliou/pi-guardrails');
+        });
+
+        it('contains all expected canonical packages', () => {
+            const expected = [
+                'npm:pi-gitnexus',
+                'npm:pi-serena-tools',
+                'npm:@zenobius/pi-worktrees',
+                'npm:@robhowley/pi-structured-return',
+            ];
+            for (const pkg of expected) {
+                expect(schema.packages).toContain(pkg);
+            }
+        });
+
+        it('packages is an array with no duplicates', () => {
+            const unique = new Set(schema.packages);
+            expect(unique.size).toBe(schema.packages.length);
+        });
+    });
+});

package/test/context.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { getCandidatePaths, resolveTargets } from '../src/core/context.js';
+
+describe('getCandidatePaths', () => {
+    it('includes Claude Code and skills-only targets', () => {
+        const candidates = getCandidatePaths();
+        expect(candidates.some(candidate => candidate.label === '~/.claude (hooks + skills)')).toBe(true);
+        expect(candidates.some(candidate => candidate.label === '~/.agents/skills')).toBe(true);
+        expect(candidates.length).toBe(2);
+    });
+});
+
+describe('resolveTargets', () => {
+    it('returns all candidate paths for the "*" selector', () => {
+        const candidates = getCandidatePaths();
+        expect(resolveTargets('*', candidates)).toEqual(candidates.map(candidate => candidate.path));
+    });
+
+    it('returns all candidate paths for the "all" selector', () => {
+        const candidates = getCandidatePaths();
+        expect(resolveTargets('all', candidates)).toEqual(candidates.map(candidate => candidate.path));
+    });
+
+    it('returns null when no selector is provided', () => {
+        expect(resolveTargets(undefined, getCandidatePaths())).toBeNull();
+    });
+
+    it('rejects unknown selectors', () => {
+        expect(() => resolveTargets('everything', getCandidatePaths())).toThrow(
+            "Unknown install target selector 'everything'. Use '*' or 'all'.",
+        );
+    });
+});

package/test/end-worktree.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_BIN = path.join(__dirname, '../dist/index.cjs');
+
+function run(args: string[], opts: { cwd?: string } = {}): { stdout: string; stderr: string; status: number } {
+    const r = spawnSync('node', [CLI_BIN, ...args], {
+        encoding: 'utf8',
+        timeout: 15000,
+        cwd: opts.cwd,
+        env: { ...process.env },
+    });
+    return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', status: r.status ?? -1 };
+}
+
+function git(args: string[], cwd: string): string {
+    const r = spawnSync('git', args, { cwd, encoding: 'utf8', stdio: 'pipe' });
+    if (r.status !== 0) throw new Error(`git ${args.join(' ')} failed: ${r.stderr}`);
+    return (r.stdout ?? '').trim();
+}
+
+let tmpBase: string;
+let mainRepo: string;
+let xtWorktree: string;
+
+beforeAll(() => {
+    tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'xtrm-end-'));
+    mainRepo = path.join(tmpBase, 'myrepo');
+    fs.mkdirSync(mainRepo);
+    git(['init'], mainRepo);
+    git(['config', 'user.email', 'test@test.com'], mainRepo);
+    git(['config', 'user.name', 'Test'], mainRepo);
+    fs.writeFileSync(path.join(mainRepo, 'README.md'), '# test');
+    git(['add', '.'], mainRepo);
+    git(['commit', '-m', 'init'], mainRepo);
+
+    // Create an xt/* worktree
+    xtWorktree = path.join(tmpBase, 'myrepo-xt-wt');
+    git(['worktree', 'add', '-b', 'xt/test-session', xtWorktree], mainRepo);
+});
+
+afterAll(() => {
+    try { fs.rmSync(tmpBase, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+// ── xt end ──────────────────────────────────────────────────────────────────
+
+describe('xt end command surface (ua3z)', () => {
+
+    it('xt end --help exits 0', () => {
+        const r = run(['end', '--help']);
+        expect(r.status).toBe(0);
+    });
+
+    it('xt end --help describes draft, keep, and yes flags', () => {
+        const r = run(['end', '--help']);
+        expect(r.stdout).toMatch(/--draft/);
+        expect(r.stdout).toMatch(/--keep/);
+        expect(r.stdout).toMatch(/--yes|-y/);
+    });
+
+    it('xt end rejects when not on an xt/* branch', () => {
+        // mainRepo is on 'main' (or 'master'), not xt/*
+        const r = run(['end'], { cwd: mainRepo });
+        const combined = r.stdout + r.stderr;
+        expect(r.status).not.toBe(0);
+        expect(combined).toMatch(/not in an xt worktree|xt\/|branch/i);
+    });
+
+    it('xt end rejects with uncommitted changes', () => {
+        // Create a dirty file in the xt worktree
+        fs.writeFileSync(path.join(xtWorktree, 'dirty.txt'), 'uncommitted');
+        const r = run(['end'], { cwd: xtWorktree });
+        const combined = r.stdout + r.stderr;
+        // Either gate fires (dirty tree or no origin/main), both are acceptable
+        expect(r.status).not.toBe(0);
+        // Clean up
+        fs.unlinkSync(path.join(xtWorktree, 'dirty.txt'));
+    });
+
+    it('xt end rejects when origin/main is not configured (no remote)', () => {
+        // The xt worktree has no remote configured, so rebase/push will fail
+        // After cleaning dirty state, end will get past the dirty-tree gate
+        // but fail at fetch/rebase
+        const r = run(['end', '-y'], { cwd: xtWorktree });
+        const combined = r.stdout + r.stderr;
+        expect(r.status).not.toBe(0);
+        // Should mention rebase, push, or remote issues
+        expect(combined).toMatch(/rebase|push|fetch|remote|origin/i);
+    });
+});
+
+// ── xt worktree ──────────────────────────────────────────────────────────────
+
+describe('xt worktree command surface (c5pi)', () => {
+
+    it('xt worktree --help exits 0', () => {
+        const r = run(['worktree', '--help']);
+        expect(r.status).toBe(0);
+    });
+
+    it('xt worktree list --help exits 0', () => {
+        const r = run(['worktree', 'list', '--help']);
+        expect(r.status).toBe(0);
+    });
+
+    it('xt worktree clean --help exits 0', () => {
+        const r = run(['worktree', 'clean', '--help']);
+        expect(r.status).toBe(0);
+    });
+
+    it('xt worktree remove --help exits 0', () => {
+        const r = run(['worktree', 'remove', '--help']);
+        expect(r.status).toBe(0);
+    });
+
+    it('xt worktree list shows xt/* worktree from main repo', () => {
+        const r = run(['worktree', 'list'], { cwd: mainRepo });
+        expect(r.status).toBe(0);
+        expect(r.stdout).toMatch(/xt\/test-session/);
+    });
+
+    it('xt worktree list shows no worktrees message when none present', () => {
+        // Create an isolated repo with no xt worktrees
+        const isolated = path.join(tmpBase, 'isolated');
+        fs.mkdirSync(isolated);
+        git(['init'], isolated);
+        git(['config', 'user.email', 'test@test.com'], isolated);
+        git(['config', 'user.name', 'Test'], isolated);
+        fs.writeFileSync(path.join(isolated, 'file.txt'), 'x');
+        git(['add', '.'], isolated);
+        git(['commit', '-m', 'init'], isolated);
+
+        const r = run(['worktree', 'list'], { cwd: isolated });
+        expect(r.status).toBe(0);
+        expect(r.stdout).toMatch(/no xt worktrees/i);
+    });
+
+    it('xt worktree clean --yes has no merged worktrees to clean', () => {
+        // The xt/test-session branch has not been merged into main
+        const r = run(['worktree', 'clean', '--yes'], { cwd: mainRepo });
+        expect(r.status).toBe(0);
+        expect(r.stdout).toMatch(/no merged xt worktrees/i);
+    });
+
+    it('xt worktree remove errors on unknown branch name', () => {
+        const r = run(['worktree', 'remove', 'nonexistent-branch'], { cwd: mainRepo });
+        expect(r.status).not.toBe(0);
+        const combined = r.stdout + r.stderr;
+        expect(combined).toMatch(/no xt worktree found/i);
+    });
+
+    it('xt worktree clean shows merged worktrees when branch is merged', () => {
+        // Merge the xt branch into main and verify clean would pick it up
+        git(['checkout', 'main'], mainRepo);
+        git(['merge', 'xt/test-session', '--no-ff', '-m', 'merge test'], mainRepo);
+
+        const r = run(['worktree', 'clean', '--yes'], { cwd: mainRepo });
+        expect(r.status).toBe(0);
+        // Should have removed the worktree since it's now merged
+        expect(r.stdout).toMatch(/removed|clean/i);
+    });
+});