@planu/cli 0.88.1 → 0.90.1

package/dist/tools/manage-git.test.js

@@ -0,0 +1,882 @@
+// Tests for handleManageGit
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../i18n/index.js', () => ({
+    t: (key) => key,
+    ti: (key, vars) => `${key}:${JSON.stringify(vars)}`,
+}));
+vi.mock('../storage/index.js', () => ({
+    specStore: {
+        getSpec: vi.fn(),
+        updateSpec: vi.fn(),
+        listSpecs: vi.fn(),
+    },
+    knowledgeStore: { getKnowledge: vi.fn() },
+}));
+// Mock promisify to return the fn as-is so we can mock execFile to return promises directly
+vi.mock('node:util', () => ({
+    promisify: (fn) => fn,
+}));
+vi.mock('node:child_process', () => ({
+    execFile: vi.fn(),
+}));
+vi.mock('node:fs/promises', () => ({
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+}));
+import { handleManageGit } from './manage-git.js';
+import { specStore, knowledgeStore } from '../storage/index.js';
+import { execFile } from 'node:child_process';
+const mockGetKnowledge = vi.mocked(knowledgeStore.getKnowledge);
+const mockGetSpec = vi.mocked(specStore.getSpec);
+const mockUpdateSpec = vi.mocked(specStore.updateSpec);
+const mockListSpecs = vi.mocked(specStore.listSpecs);
+const mockExecFile = execFile;
+const baseKnowledge = {
+    language: 'typescript',
+    framework: 'express',
+    projectPath: '/test/project',
+    stack: [],
+    conventions: {},
+    architecture: { primary: 'monolith', secondary: [], layers: [] },
+    database: 'postgresql',
+    testCommand: 'npm test',
+    buildCommand: 'npm run build',
+    linting: { detectedLinters: [{ tool: 'eslint' }] },
+    apiContracts: [],
+    layers: [],
+};
+const baseSpec = {
+    id: 'SPEC-001',
+    slug: 'user-auth',
+    title: 'User Authentication',
+    type: 'feature',
+    scope: 'feature',
+    target: 'backend',
+    tags: ['auth'],
+    status: 'approved',
+    risk: 'medium',
+    difficulty: 3,
+    estimation: { devHours: 8, reviewHours: 2, totalCostUsd: 100.00 },
+    dependencies: [],
+    gitBranch: null,
+    impactAnalysis: { requiresMigration: false, requiresFeatureFlag: false },
+};
+function mockGitSuccess(stdout = '') {
+    mockExecFile.mockResolvedValue({ stdout, stderr: '' });
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetKnowledge.mockResolvedValue(baseKnowledge);
+    mockUpdateSpec.mockResolvedValue(undefined);
+});
+describe('handleManageGit', () => {
+    // === create-branch ===
+    it('should error when create-branch called without specId', async () => {
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('specId is required');
+    });
+    it('should error when spec not found for create-branch', async () => {
+        mockGetSpec.mockResolvedValue(null);
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+            specId: 'SPEC-999',
+        });
+        expect(result.isError).toBe(true);
+    });
+    it('should create a new branch', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        // branch --list returns empty (no existing branch), then checkout -b succeeds
+        mockExecFile.mockResolvedValue({ stdout: '', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+            specId: 'SPEC-001',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('create-branch');
+        expect(data.branchName).toContain('feat/');
+        expect(data.branchName).toContain('SPEC-001');
+    });
+    // === generate-pr ===
+    it('should error when generate-pr called without specId', async () => {
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+        });
+        expect(result.isError).toBe(true);
+    });
+    it('should generate PR template', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-user-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--oneline')) {
+                return Promise.resolve({ stdout: 'abc1234 feat: add auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--name-only')) {
+                return Promise.resolve({ stdout: 'src/auth.ts\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+            specId: 'SPEC-001',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('generate-pr');
+        expect(data.prTemplate).toBeDefined();
+        expect(data.prTemplate.title).toContain('SPEC-001');
+    });
+    // === link-commits ===
+    it('should link commits to specs', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--grep=SPEC-')) {
+                return Promise.resolve({ stdout: 'abc12345|[SPEC-001] feat: auth|dev|2025-01-01T00:00:00Z\n', stderr: '' });
+            }
+            if (argsArr.includes('diff-tree')) {
+                return Promise.resolve({ stdout: 'src/auth.ts\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'link-commits',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('link-commits');
+        expect(data.linkedCommits).toBeDefined();
+    });
+    // === generate-changelog ===
+    it('should generate changelog', async () => {
+        mockListSpecs.mockResolvedValue([
+            { ...baseSpec, status: 'done' },
+        ]);
+        mockGitSuccess('abc1234 feat: something\n');
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-changelog',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('generate-changelog');
+        expect(data.changelog).toBeDefined();
+        expect(data.changelog.content).toContain('Changelog');
+    });
+    // === setup-hooks ===
+    it('should setup git hooks', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--git-dir')) {
+                return Promise.resolve({ stdout: '.git\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'setup-hooks',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('setup-hooks');
+        expect(data.hooksInstalled).toBeDefined();
+        expect(data.hooksInstalled).toContain('pre-commit');
+        expect(data.hooksInstalled).toContain('commit-msg');
+        expect(data.hooksInstalled).toContain('pre-push');
+    });
+    // === check-branch ===
+    it('should check branch naming', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockGitSuccess('feat/SPEC-001-user-auth\n');
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'check-branch',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('check-branch');
+        expect(data.followsConvention).toBe(true);
+    });
+    // === status ===
+    it('should return git status', async () => {
+        mockListSpecs.mockResolvedValue([
+            { ...baseSpec, status: 'implementing' },
+        ]);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--porcelain')) {
+                return Promise.resolve({ stdout: ' M src/auth.ts\n', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--count')) {
+                return Promise.resolve({ stdout: '3\n', stderr: '' });
+            }
+            if (argsArr.includes('--format=%s')) {
+                return Promise.resolve({ stdout: '[SPEC-001] auth\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('status');
+        expect(data.status).toBeDefined();
+    });
+    // === unknown action ===
+    it('should return error for unknown action', async () => {
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'unknown',
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Unknown git action');
+    });
+    // === general error handling ===
+    it('should catch and return errors from git commands', async () => {
+        mockGetKnowledge.mockRejectedValue(new Error('Network error'));
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Network error');
+    });
+    // --- Coverage for link-commits with no matching commits (line 374+) ---
+    it('should return empty linkedCommits when git log has no output', async () => {
+        mockExecFile.mockResolvedValue({ stdout: '', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'link-commits',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.linkedCommits).toHaveLength(0);
+        expect(data.message).toContain('0 commit(s)');
+    });
+    it('should handle link-commits when git log throws error', async () => {
+        // First call is for resolveProjectPath, subsequent calls fail
+        let callCount = 0;
+        mockExecFile.mockImplementation(() => {
+            callCount++;
+            if (callCount <= 1) {
+                // This is still resolved through resolveProjectPath -> knowledge
+                return Promise.reject(new Error('fatal: not a git repository'));
+            }
+            return Promise.reject(new Error('git error'));
+        });
+        // But resolveProjectPath uses knowledgeStore, not git. So the first git call is the log.
+        // When git log fails, it should catch and return empty commits
+        mockExecFile.mockRejectedValue({ stderr: 'fatal: bad revision', message: 'bad revision' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'link-commits',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.linkedCommits).toHaveLength(0);
+    });
+    it('should handle link-commits lines with missing hash/message', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--grep=SPEC-')) {
+                // One valid line and one with missing fields
+                return Promise.resolve({
+                    stdout: 'abc12345|[SPEC-001] feat: auth|dev|2025-01-01T00:00:00Z\n|||\n',
+                    stderr: '',
+                });
+            }
+            if (argsArr.includes('diff-tree')) {
+                return Promise.resolve({ stdout: 'src/file.ts\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'link-commits',
+        });
+        const data = JSON.parse(result.content[0].text);
+        // Only the valid line should be processed, empty hash/message lines skipped
+        expect(data.linkedCommits).toHaveLength(1);
+    });
+    it('should handle diff-tree failure for individual commits', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--grep=SPEC-')) {
+                return Promise.resolve({
+                    stdout: 'abc12345|[SPEC-001] feat: auth|dev|2025-01-01T00:00:00Z\n',
+                    stderr: '',
+                });
+            }
+            if (argsArr.includes('diff-tree')) {
+                return Promise.reject(new Error('diff-tree failed'));
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'link-commits',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.linkedCommits).toHaveLength(1);
+        expect(data.linkedCommits[0].filesChanged).toHaveLength(0);
+    });
+    // --- Coverage for generate-pr with master fallback (line 679+) ---
+    it('should fallback to master branch when main does not exist', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-user-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--verify') && argsArr.includes('main')) {
+                return Promise.reject(new Error('not found'));
+            }
+            if (argsArr.includes('--verify') && argsArr.includes('master')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--oneline')) {
+                return Promise.resolve({ stdout: 'abc1234 feat: add auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--name-only')) {
+                return Promise.resolve({ stdout: 'src/auth.ts\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+            specId: 'SPEC-001',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[0].text);
+        expect(data.prTemplate).toBeDefined();
+    });
+    it('should fallback to HEAD~10 when both main and master do not exist', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-user-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.reject(new Error('not found'));
+            }
+            if (argsArr.includes('--oneline')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--name-only')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+            specId: 'SPEC-001',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[0].text);
+        expect(data.prTemplate.body).toContain('no changes detected');
+    });
+    // --- Coverage for generate-pr commit log failure ---
+    it('should handle commit log failure in generate-pr', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-user-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--oneline')) {
+                return Promise.reject(new Error('log failed'));
+            }
+            if (argsArr.includes('--name-only')) {
+                return Promise.reject(new Error('diff failed'));
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+            specId: 'SPEC-001',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[0].text);
+        expect(data.prTemplate.body).toContain('unable to determine');
+    });
+    // --- Coverage for generate-pr with high/critical risk labels ---
+    it('should add risk and scope labels for high-risk architectural spec', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            risk: 'critical',
+            scope: 'architectural',
+            impactAnalysis: { requiresMigration: true, requiresFeatureFlag: true },
+        });
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.prTemplate.labels).toContain('risk:critical');
+        expect(data.prTemplate.labels).toContain('scope:architectural');
+        expect(data.prTemplate.body).toContain('Migration tested');
+        expect(data.prTemplate.body).toContain('Feature flag configured');
+    });
+    // --- Coverage for status: master fallback (lines 731-735) ---
+    it('should fallback to master in status when main is not found', async () => {
+        mockListSpecs.mockResolvedValue([]);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--porcelain')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--verify') && argsArr.includes('main')) {
+                return Promise.reject(new Error('not found'));
+            }
+            if (argsArr.includes('--verify') && argsArr.includes('master')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--count')) {
+                return Promise.resolve({ stdout: '5\n', stderr: '' });
+            }
+            if (argsArr.includes('--format=%s')) {
+                return Promise.resolve({ stdout: '[SPEC-001] feat\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.status.commitsAhead).toBe(5);
+    });
+    it('should handle status when both main and master do not exist', async () => {
+        mockListSpecs.mockResolvedValue([]);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--porcelain')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.reject(new Error('not found'));
+            }
+            if (argsArr.includes('--format=%s')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        const data = JSON.parse(result.content[0].text);
+        // baseBranch is '', so commitsAhead remains 0
+        expect(data.status.commitsAhead).toBe(0);
+    });
+    // --- Coverage for create-branch: existing branch checkout ---
+    it('should switch to existing branch when it already exists', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--list')) {
+                return Promise.resolve({ stdout: '  feat/SPEC-001-user-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('checkout')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.message).toContain('Switched to existing branch');
+    });
+    // --- Coverage for create-branch: branch list failure ---
+    it('should create branch when branch list command fails', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        let callIdx = 0;
+        mockExecFile.mockImplementation(() => {
+            callIdx++;
+            if (callIdx === 1) {
+                // branch --list fails
+                return Promise.reject(new Error('git error'));
+            }
+            // checkout -b succeeds
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('create-branch');
+        expect(data.branchName).toContain('SPEC-001');
+    });
+    // --- Coverage for setup-hooks: spec-id commit format ---
+    it('should setup hooks with spec-id commit format', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--git-dir')) {
+                return Promise.resolve({ stdout: '.git\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'setup-hooks',
+            config: {
+                commitFormat: 'spec-id',
+                requireSpecInCommit: false,
+            },
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.hooksInstalled).toContain('commit-msg');
+    });
+    // --- Coverage for setup-hooks: custom commit format ---
+    it('should setup hooks with custom commit format', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--git-dir')) {
+                return Promise.resolve({ stdout: '.git\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'setup-hooks',
+            config: {
+                commitFormat: 'custom',
+            },
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.hooksInstalled).toContain('commit-msg');
+    });
+    // --- Coverage for setup-hooks: git-dir fallback ---
+    it('should fallback to .git/hooks when git rev-parse fails', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--git-dir')) {
+                return Promise.reject(new Error('not a git repo'));
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'setup-hooks',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.hooksInstalled).toContain('pre-commit');
+    });
+    // --- Coverage for check-branch: protected branch ---
+    it('should detect protected branch issues', async () => {
+        mockExecFile.mockResolvedValue({ stdout: 'main\n', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'check-branch',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.isProtected).toBe(true);
+        expect(data.issues.length).toBeGreaterThan(0);
+        expect(data.issues[0]).toContain('protected branch');
+    });
+    // --- Coverage for check-branch: non-convention branch that is not protected ---
+    it('should detect non-convention branch name', async () => {
+        mockExecFile.mockResolvedValue({ stdout: 'my-random-branch\n', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'check-branch',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.followsConvention).toBe(false);
+        expect(data.isProtected).toBe(false);
+        expect(data.issues.some((i) => i.includes('naming convention'))).toBe(true);
+    });
+    // --- Coverage for check-branch: spec referenced in branch but not found ---
+    it('should warn when spec referenced in branch name is not found', async () => {
+        mockGetSpec.mockResolvedValue(null);
+        mockExecFile.mockResolvedValue({ stdout: 'feat/SPEC-999-missing\n', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'check-branch',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.linkedSpecId).toBe('SPEC-999');
+        expect(data.specExists).toBe(false);
+        expect(data.issues.some((i) => i.includes('not found in project'))).toBe(true);
+    });
+    // --- Coverage for generate-changelog: filtered by specId ---
+    it('should generate changelog filtered by specific specId', async () => {
+        mockListSpecs.mockResolvedValue([
+            { ...baseSpec, id: 'SPEC-001', status: 'done' },
+            { ...baseSpec, id: 'SPEC-002', status: 'done', title: 'Other Feature' },
+        ]);
+        mockExecFile.mockResolvedValue({ stdout: '[SPEC-001] feat: auth\nabc1234 misc change\n', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-changelog',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.changelog.content).toContain('SPEC-001');
+    });
+    // --- Coverage for generate-changelog: git log failure ---
+    it('should generate changelog even when git log fails', async () => {
+        mockListSpecs.mockResolvedValue([
+            { ...baseSpec, status: 'done' },
+        ]);
+        mockExecFile.mockRejectedValue(new Error('git log failed'));
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-changelog',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.changelog).toBeDefined();
+    });
+    // --- Coverage for non-Error thrown in catch block ---
+    it('should handle non-Error thrown values', async () => {
+        mockGetKnowledge.mockRejectedValue('string error');
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('string error');
+    });
+    // --- Coverage for generate-pr spec not found ---
+    it('should error when spec not found for generate-pr', async () => {
+        mockGetSpec.mockResolvedValue(null);
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'generate-pr',
+            specId: 'SPEC-999',
+        });
+        expect(result.isError).toBe(true);
+    });
+    // --- Coverage for project not found ---
+    it('should error when project not found', async () => {
+        mockGetKnowledge.mockResolvedValue(null);
+        const result = await handleManageGit({
+            projectId: 'missing',
+            action: 'status',
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Project not found');
+    });
+    // --- Coverage for status: on same branch as base ---
+    it('should not count commits ahead when on base branch', async () => {
+        mockListSpecs.mockResolvedValue([]);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'main\n', stderr: '' });
+            }
+            if (argsArr.includes('--porcelain')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--format=%s')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.status.commitsAhead).toBe(0);
+    });
+    // --- Coverage for status: rev-list count failure ---
+    it('should handle rev-list count failure in status', async () => {
+        mockListSpecs.mockResolvedValue([]);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001\n', stderr: '' });
+            }
+            if (argsArr.includes('--porcelain')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--count')) {
+                return Promise.reject(new Error('rev-list failed'));
+            }
+            if (argsArr.includes('--format=%s')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.status.commitsAhead).toBe(0);
+    });
+    // --- Coverage for link-commits: commit without SPEC pattern in message uses specId ---
+    it('should use specId as fallback when commit message has no SPEC pattern', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--grep=SPEC-001')) {
+                return Promise.resolve({
+                    stdout: 'abc12345|feat: auth without spec ref|dev|2025-01-01T00:00:00Z\n',
+                    stderr: '',
+                });
+            }
+            if (argsArr.includes('diff-tree')) {
+                return Promise.resolve({ stdout: 'src/auth.ts\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'link-commits',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.linkedCommits).toHaveLength(1);
+        expect(data.linkedCommits[0].specId).toBe('SPEC-001');
+    });
+    // --- Coverage for create-branch with different spec types ---
+    it('should use refactor prefix for refactor spec type', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            type: 'refactor',
+        });
+        mockExecFile.mockResolvedValue({ stdout: '', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.branchName).toContain('refactor/');
+    });
+    it('should use fix prefix for bugfix spec type', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            type: 'bugfix',
+        });
+        mockExecFile.mockResolvedValue({ stdout: '', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'create-branch',
+            specId: 'SPEC-001',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.branchName).toContain('fix/');
+    });
+    // --- Coverage for setup-hooks with requireSpecInCommit true (explicit) ---
+    it('should setup hooks with requireSpecInCommit enabled and custom protectedBranches', async () => {
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--git-dir')) {
+                return Promise.resolve({ stdout: '.git\n', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'setup-hooks',
+            config: {
+                requireSpecInCommit: true,
+                protectedBranches: ['main', 'staging'],
+            },
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.hooksInstalled).toContain('pre-commit');
+        expect(data.hooksInstalled).toContain('commit-msg');
+        expect(data.hooksInstalled).toContain('pre-push');
+    });
+    // --- Coverage for check-branch with custom config ---
+    it('should check branch with custom protectedBranches config', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockExecFile.mockResolvedValue({ stdout: 'staging\n', stderr: '' });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'check-branch',
+            config: {
+                protectedBranches: ['main', 'staging'],
+            },
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.action).toBe('check-branch');
+        expect(data.isProtected).toBe(true);
+        expect(data.branchName).toBe('staging');
+    });
+    // --- Coverage for status: rev-list returns non-numeric string (line 742: parseInt || 0) ---
+    it('should default commitsAhead to 0 when rev-list returns non-numeric output', async () => {
+        mockListSpecs.mockResolvedValue([]);
+        mockExecFile.mockImplementation((_cmd, args) => {
+            const argsArr = args;
+            if (argsArr.includes('--abbrev-ref')) {
+                return Promise.resolve({ stdout: 'feat/SPEC-001-auth\n', stderr: '' });
+            }
+            if (argsArr.includes('--porcelain')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--verify')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            if (argsArr.includes('--count')) {
+                // Return non-numeric string so parseInt returns NaN, triggering || 0
+                return Promise.resolve({ stdout: 'not-a-number\n', stderr: '' });
+            }
+            if (argsArr.includes('--format=%s')) {
+                return Promise.resolve({ stdout: '', stderr: '' });
+            }
+            return Promise.resolve({ stdout: '', stderr: '' });
+        });
+        const result = await handleManageGit({
+            projectId: 'proj-1',
+            action: 'status',
+        });
+        const data = JSON.parse(result.content[0].text);
+        expect(data.status.commitsAhead).toBe(0);
+    });
+});
+//# sourceMappingURL=manage-git.test.js.map