@doingdev/opencode-claude-manager-plugin 0.1.35 → 0.1.43

package/dist/test/claude-manager.plugin.test.js

@@ -0,0 +1,331 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
+import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, ALL_RESTRICTED_TOOL_IDS, } from '../src/plugin/agent-hierarchy.js';
+import { managerPromptRegistry } from '../src/prompts/registry.js';
+/** All engineer tools — none belong to CTO. */
+const ENGINEER_TOOL_IDS = [
+    'explore',
+    'implement',
+    'compact_context',
+    'clear_session',
+    'session_health',
+    'list_transcripts',
+    'list_history',
+];
+describe('ClaudeManagerPlugin', () => {
+    it('configures cto with git and approval tools but denies all engineer tools', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const cto = agents[AGENT_CTO];
+        expect(cto).toBeDefined();
+        expect(cto.mode).toBe('primary');
+        // CTO should have read-only codebase and utility tools
+        expect(cto.permission).toMatchObject({
+            '*': 'deny',
+            read: 'allow',
+            grep: 'allow',
+            glob: 'allow',
+            codesearch: 'allow',
+            webfetch: 'allow',
+            websearch: 'allow',
+            todowrite: 'allow',
+            todoread: 'allow',
+            question: 'allow',
+        });
+        // CTO should have git tools allowed
+        expect(cto.permission).toHaveProperty('git_diff', 'allow');
+        expect(cto.permission).toHaveProperty('git_commit', 'allow');
+        expect(cto.permission).toHaveProperty('git_reset', 'allow');
+        // CTO should have approval tools allowed
+        expect(cto.permission).toHaveProperty('approval_policy', 'allow');
+        expect(cto.permission).toHaveProperty('approval_decisions', 'allow');
+        expect(cto.permission).toHaveProperty('approval_update', 'allow');
+        // CTO should have ALL engineer tools DENIED
+        for (const toolId of ENGINEER_TOOL_IDS) {
+            expect(cto.permission).toHaveProperty(toolId, 'deny');
+        }
+        // CTO should have task permission to spawn engineer subagents
+        expect(cto.permission).toHaveProperty('task');
+        expect(cto.permission['task']).toMatchObject({
+            '*': 'deny',
+            engineer_plan: 'allow',
+            engineer_build: 'allow',
+        });
+        // CTO should NOT have bash or edit
+        expect(cto.permission).not.toHaveProperty('bash');
+        expect(cto.permission).not.toHaveProperty('edit');
+    });
+    it('configures engineer_plan wrapper with only plan-mode send tool', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const engineerPlan = agents[AGENT_ENGINEER_PLAN];
+        expect(engineerPlan).toBeDefined();
+        expect(engineerPlan.mode).toBe('subagent');
+        // Should allow explore and shared session tools
+        expect(engineerPlan.permission).toHaveProperty('explore', 'allow');
+        expect(engineerPlan.permission).toHaveProperty('compact_context', 'allow');
+        expect(engineerPlan.permission).toHaveProperty('session_health', 'allow');
+        // Should DENY the build-mode send
+        expect(engineerPlan.permission).toHaveProperty('implement', 'deny');
+        // Should deny git and approval tools
+        expect(engineerPlan.permission).toHaveProperty('git_diff', 'deny');
+        expect(engineerPlan.permission).toHaveProperty('approval_policy', 'deny');
+        // Should have read-only investigation tools
+        expect(engineerPlan.permission).toMatchObject({
+            read: 'allow',
+            grep: 'allow',
+            glob: 'allow',
+            codesearch: 'allow',
+            webfetch: 'allow',
+            websearch: 'allow',
+            lsp: 'allow',
+            todowrite: 'allow',
+            todoread: 'allow',
+            question: 'allow',
+        });
+    });
+    it('configures engineer_build wrapper with only build-mode send tool', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        const engineerBuild = agents[AGENT_ENGINEER_BUILD];
+        expect(engineerBuild).toBeDefined();
+        expect(engineerBuild.mode).toBe('subagent');
+        // Should allow implement and shared session tools
+        expect(engineerBuild.permission).toHaveProperty('implement', 'allow');
+        expect(engineerBuild.permission).toHaveProperty('compact_context', 'allow');
+        expect(engineerBuild.permission).toHaveProperty('session_health', 'allow');
+        // Should DENY the plan-mode send
+        expect(engineerBuild.permission).toHaveProperty('explore', 'deny');
+        // Should deny git and approval tools
+        expect(engineerBuild.permission).toHaveProperty('git_diff', 'deny');
+        expect(engineerBuild.permission).toHaveProperty('approval_policy', 'deny');
+        // Should have read-only investigation tools
+        expect(engineerBuild.permission).toMatchObject({
+            read: 'allow',
+            grep: 'allow',
+            glob: 'allow',
+            codesearch: 'allow',
+            webfetch: 'allow',
+            websearch: 'allow',
+            lsp: 'allow',
+            todowrite: 'allow',
+            todoread: 'allow',
+            question: 'allow',
+        });
+    });
+    it('CTO description reflects delegation-first behavior', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        expect(agents[AGENT_CTO].description).toContain('Delegates by default');
+        expect(agents[AGENT_CTO].description).toContain('minimal spot-checks');
+    });
+    it('engineer_plan description reflects thin wrapper dispatching to Claude Code', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        expect(agents[AGENT_ENGINEER_PLAN].description).toContain('Thin high-judgment wrapper');
+        expect(agents[AGENT_ENGINEER_PLAN].description).toContain('dispatches to Claude Code');
+    });
+    it('engineer_build description reflects thin wrapper dispatching to Claude Code', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        expect(agents[AGENT_ENGINEER_BUILD].description).toContain('Thin high-judgment wrapper');
+        expect(agents[AGENT_ENGINEER_BUILD].description).toContain('dispatches to Claude Code');
+    });
+    it('explore tool description marks it as preferred first step', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        expect(tools['explore'].description).toContain('Preferred first step before implementation');
+    });
+    it('implement tool description marks it for code changes', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        expect(tools['implement'].description).toContain('Implement code changes');
+    });
+    it('does not register old agent names', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        expect(agents).not.toHaveProperty('claude-manager');
+        expect(agents).not.toHaveProperty('claude-manager-research');
+        expect(agents).not.toHaveProperty('claude-cto');
+        expect(agents).not.toHaveProperty('manager');
+    });
+    it('does not register any slash commands', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        expect(config).not.toHaveProperty('command');
+    });
+    it('exposes freshSession argument on explore defaulting to false', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const exploreTool = tools['explore'];
+        expect(exploreTool).toBeDefined();
+        const freshSchema = exploreTool.args.freshSession;
+        expect(freshSchema).toBeDefined();
+        expect(freshSchema.parse(undefined)).toBe(false);
+        expect(freshSchema.safeParse(true).success).toBe(true);
+        expect(freshSchema.safeParse(false).success).toBe(true);
+    });
+    it('exposes model argument as enum of allowed models on implement', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const implementTool = tools['implement'];
+        const modelSchema = implementTool.args.model;
+        expect(modelSchema).toBeDefined();
+        expect(modelSchema.safeParse('claude-opus-4-6').success).toBe(true);
+        expect(modelSchema.safeParse('claude-sonnet-4-6').success).toBe(true);
+        expect(modelSchema.safeParse('claude-sonnet-4-5').success).toBe(true);
+        expect(modelSchema.safeParse(undefined).success).toBe(true);
+        expect(modelSchema.safeParse('claude-haiku-4-5').success).toBe(false);
+        expect(modelSchema.safeParse('anything-else').success).toBe(false);
+    });
+    it('exposes effort argument as enum defaulting to high on explore', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const exploreTool = tools['explore'];
+        const effortSchema = exploreTool.args.effort;
+        expect(effortSchema).toBeDefined();
+        expect(effortSchema.safeParse('low').success).toBe(true);
+        expect(effortSchema.safeParse('medium').success).toBe(true);
+        expect(effortSchema.safeParse('high').success).toBe(true);
+        expect(effortSchema.safeParse('max').success).toBe(true);
+        expect(effortSchema.parse(undefined)).toBe('high');
+        expect(effortSchema.safeParse('turbo').success).toBe(false);
+    });
+    it('exposes compact_context tool', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        expect(tools['compact_context']).toBeDefined();
+    });
+    it('exposes all tool IDs matching the hierarchy constants', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
+            expect(tools).toHaveProperty(toolId);
+        }
+    });
+    it('does not expose old claude_manager_* tool IDs', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const oldToolIds = [
+            'claude_manager_send',
+            'claude_manager_compact',
+            'claude_manager_git_diff',
+            'claude_manager_git_commit',
+            'claude_manager_git_reset',
+            'claude_manager_clear',
+            'claude_manager_status',
+            'claude_manager_metadata',
+            'claude_manager_sessions',
+            'claude_manager_runs',
+            'claude_manager_approval_policy',
+            'claude_manager_approval_decisions',
+            'claude_manager_approval_update',
+        ];
+        for (const oldId of oldToolIds) {
+            expect(tools).not.toHaveProperty(oldId);
+        }
+    });
+    describe('wrapper prompts include discovered Claude files', () => {
+        const tmpDirs = [];
+        async function makeTmp() {
+            const d = await mkdtemp(join(tmpdir(), 'plugin-test-'));
+            tmpDirs.push(d);
+            return d;
+        }
+        afterEach(async () => {
+            for (const d of tmpDirs) {
+                await rm(d, { recursive: true, force: true });
+            }
+            tmpDirs.length = 0;
+        });
+        it('injects project Claude files into engineer plan/build wrapper prompts', async () => {
+            const worktree = await makeTmp();
+            await writeFile(join(worktree, 'CLAUDE.md'), 'Use pnpm. No default exports.');
+            await mkdir(join(worktree, '.claude'), { recursive: true });
+            await writeFile(join(worktree, '.claude/settings.md'), 'Extra settings');
+            const plugin = await ClaudeManagerPlugin({ worktree });
+            const config = {};
+            await plugin.config?.(config);
+            const agents = config.agent;
+            const planPrompt = agents[AGENT_ENGINEER_PLAN].prompt;
+            const buildPrompt = agents[AGENT_ENGINEER_BUILD].prompt;
+            // Both wrapper prompts should contain discovered file content
+            expect(planPrompt).toContain('## Project Claude Files');
+            expect(planPrompt).toContain('### CLAUDE.md');
+            expect(planPrompt).toContain('Use pnpm. No default exports.');
+            expect(planPrompt).toContain('### .claude/settings.md');
+            expect(planPrompt).toContain('Extra settings');
+            expect(buildPrompt).toContain('## Project Claude Files');
+            expect(buildPrompt).toContain('### CLAUDE.md');
+            expect(buildPrompt).toContain('Use pnpm. No default exports.');
+        });
+        it('CTO prompt stays unchanged regardless of Claude files', async () => {
+            const worktree = await makeTmp();
+            await writeFile(join(worktree, 'CLAUDE.md'), 'project rules');
+            const plugin = await ClaudeManagerPlugin({ worktree });
+            const config = {};
+            await plugin.config?.(config);
+            const agents = config.agent;
+            expect(agents[AGENT_CTO].prompt).toBe(managerPromptRegistry.ctoSystemPrompt);
+        });
+        it('wrapper prompts equal base when no Claude files exist', async () => {
+            const worktree = await makeTmp();
+            const plugin = await ClaudeManagerPlugin({ worktree });
+            const config = {};
+            await plugin.config?.(config);
+            const agents = config.agent;
+            expect(agents[AGENT_ENGINEER_PLAN].prompt).toBe(managerPromptRegistry.engineerPlanPrompt);
+            expect(agents[AGENT_ENGINEER_BUILD].prompt).toBe(managerPromptRegistry.engineerBuildPrompt);
+        });
+    });
+});

package/dist/test/context-tracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/context-tracker.test.js

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import { ContextTracker } from '../src/manager/context-tracker.js';
+describe('ContextTracker', () => {
+    it('starts with null estimates', () => {
+        const tracker = new ContextTracker();
+        const snap = tracker.snapshot();
+        expect(snap.estimatedContextPercent).toBeNull();
+        expect(snap.warningLevel).toBe('ok');
+        expect(snap.totalTurns).toBe(0);
+        expect(snap.totalCostUsd).toBe(0);
+        expect(snap.compactionCount).toBe(0);
+    });
+    it('estimates context % from input tokens (tier 1)', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            inputTokens: 100_000,
+            contextWindowSize: 200_000,
+            turns: 10,
+            totalCostUsd: 0.5,
+        });
+        const snap = tracker.snapshot();
+        expect(snap.estimatedContextPercent).toBe(50);
+        expect(snap.warningLevel).toBe('moderate');
+    });
+    it('estimates context % from cost (tier 2) when no token data', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            totalCostUsd: 0.5,
+            turns: 10,
+        });
+        const snap = tracker.snapshot();
+        // 0.5 * 130_000 = 65_000 / 200_000 = 32.5%
+        expect(snap.estimatedContextPercent).toBe(33);
+        expect(snap.warningLevel).toBe('ok');
+    });
+    it('estimates context % from turns (tier 3) when no cost or tokens', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({ turns: 20 });
+        const snap = tracker.snapshot();
+        // 20 * 6_000 = 120_000 / 200_000 = 60%
+        expect(snap.estimatedContextPercent).toBe(60);
+        expect(snap.warningLevel).toBe('moderate');
+    });
+    it('caps at 100%', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            inputTokens: 300_000,
+            contextWindowSize: 200_000,
+        });
+        expect(tracker.estimateContextPercent()).toBe(100);
+    });
+    it('returns critical warning at 85%+', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            inputTokens: 180_000,
+            contextWindowSize: 200_000,
+        });
+        expect(tracker.warningLevel()).toBe('critical');
+    });
+    it('returns high warning at 70-85%', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            inputTokens: 150_000,
+            contextWindowSize: 200_000,
+        });
+        expect(tracker.warningLevel()).toBe('high');
+    });
+    it('detects compaction from input token drop', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            inputTokens: 150_000,
+            contextWindowSize: 200_000,
+        });
+        expect(tracker.snapshot().compactionCount).toBe(0);
+        // After compaction, input tokens drop significantly
+        tracker.recordResult({
+            inputTokens: 40_000,
+            contextWindowSize: 200_000,
+        });
+        expect(tracker.snapshot().compactionCount).toBe(1);
+        expect(tracker.estimateContextPercent()).toBe(20);
+    });
+    it('tracks explicit compaction events', () => {
+        const tracker = new ContextTracker();
+        tracker.recordCompaction();
+        tracker.recordCompaction();
+        expect(tracker.snapshot().compactionCount).toBe(2);
+    });
+    it('resets all state', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({
+            sessionId: 'ses_123',
+            inputTokens: 100_000,
+            outputTokens: 5_000,
+            contextWindowSize: 200_000,
+            turns: 10,
+            totalCostUsd: 0.5,
+        });
+        tracker.recordCompaction();
+        tracker.reset();
+        const snap = tracker.snapshot();
+        expect(snap.sessionId).toBeNull();
+        expect(snap.totalTurns).toBe(0);
+        expect(snap.totalCostUsd).toBe(0);
+        expect(snap.latestInputTokens).toBeNull();
+        expect(snap.compactionCount).toBe(0);
+        expect(snap.estimatedContextPercent).toBeNull();
+    });
+    it('restores from persisted state', () => {
+        const tracker = new ContextTracker();
+        tracker.restore({
+            sessionId: 'ses_456',
+            totalTurns: 15,
+            totalCostUsd: 0.8,
+            estimatedContextPercent: 60,
+            contextWindowSize: 200_000,
+            latestInputTokens: 120_000,
+        });
+        const snap = tracker.snapshot();
+        expect(snap.sessionId).toBe('ses_456');
+        expect(snap.totalTurns).toBe(15);
+        expect(snap.totalCostUsd).toBe(0.8);
+        expect(snap.estimatedContextPercent).toBe(60);
+    });
+    it('checks token threshold', () => {
+        const tracker = new ContextTracker();
+        expect(tracker.isAboveTokenThreshold()).toBe(false);
+        tracker.recordResult({ inputTokens: 150_000 });
+        expect(tracker.isAboveTokenThreshold(200_000)).toBe(false);
+        tracker.recordResult({ inputTokens: 210_000 });
+        expect(tracker.isAboveTokenThreshold(200_000)).toBe(true);
+    });
+    it('accumulates session ID from results', () => {
+        const tracker = new ContextTracker();
+        tracker.recordResult({ sessionId: 'ses_abc' });
+        expect(tracker.snapshot().sessionId).toBe('ses_abc');
+    });
+});

package/dist/test/file-run-state-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/file-run-state-store.test.js

@@ -0,0 +1,82 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { FileRunStateStore } from '../src/state/file-run-state-store.js';
+const tempDirectories = [];
+function createRun(cwd, id) {
+    return {
+        id,
+        cwd,
+        task: 'Implement feature',
+        status: 'completed',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        sessionId: null,
+        sessionHistory: [],
+        messages: [],
+        actions: [],
+        commits: [],
+        context: {
+            sessionId: null,
+            totalTurns: 0,
+            totalCostUsd: 0,
+            latestInputTokens: null,
+            latestOutputTokens: null,
+            contextWindowSize: null,
+            estimatedContextPercent: null,
+            warningLevel: 'ok',
+            compactionCount: 0,
+        },
+        finalSummary: 'Done.',
+    };
+}
+describe('FileRunStateStore', () => {
+    afterEach(async () => {
+        await Promise.all(tempDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+    });
+    it('persists and reloads run records', async () => {
+        const cwd = await mkdtemp(path.join(os.tmpdir(), 'file-run-state-store-'));
+        tempDirectories.push(cwd);
+        const store = new FileRunStateStore();
+        const run = createRun(cwd, 'run_1');
+        await store.saveRun(run);
+        const loadedRun = await store.getRun(cwd, 'run_1');
+        expect(loadedRun).toMatchObject({ id: 'run_1', finalSummary: 'Done.' });
+        expect(await store.listRuns(cwd)).toHaveLength(1);
+    });
+    it('serializes concurrent updates for the same run', async () => {
+        const cwd = await mkdtemp(path.join(os.tmpdir(), 'file-run-state-store-'));
+        tempDirectories.push(cwd);
+        const store = new FileRunStateStore();
+        const run = createRun(cwd, 'run_2');
+        run.status = 'running';
+        await store.saveRun(run);
+        await Promise.all([
+            store.updateRun(cwd, 'run_2', (currentRun) => ({
+                ...currentRun,
+                messages: [
+                    ...currentRun.messages,
+                    {
+                        timestamp: new Date().toISOString(),
+                        direction: 'sent',
+                        text: 'Task A',
+                    },
+                ],
+            })),
+            store.updateRun(cwd, 'run_2', (currentRun) => ({
+                ...currentRun,
+                messages: [
+                    ...currentRun.messages,
+                    {
+                        timestamp: new Date().toISOString(),
+                        direction: 'sent',
+                        text: 'Task B',
+                    },
+                ],
+            })),
+        ]);
+        const updatedRun = await store.getRun(cwd, 'run_2');
+        expect(updatedRun?.messages.map((m) => m.text).sort()).toEqual(['Task A', 'Task B']);
+    });
+});

package/dist/test/git-operations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/git-operations.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { GitOperations } from '../src/manager/git-operations.js';
+const execFileAsync = promisify(execFile);
+async function createTestRepo() {
+    const dir = await mkdtemp(join(tmpdir(), 'git-ops-test-'));
+    await execFileAsync('git', ['init'], { cwd: dir });
+    await execFileAsync('git', ['config', 'user.email', 'test@test.com'], {
+        cwd: dir,
+    });
+    await execFileAsync('git', ['config', 'user.name', 'Test'], { cwd: dir });
+    // Create initial commit
+    await writeFile(join(dir, 'README.md'), '# Test\n');
+    await execFileAsync('git', ['add', '-A'], { cwd: dir });
+    await execFileAsync('git', ['commit', '-m', 'initial'], { cwd: dir });
+    return dir;
+}
+describe('GitOperations', () => {
+    it('reports no diff on clean repo', async () => {
+        const dir = await createTestRepo();
+        const git = new GitOperations(dir);
+        const result = await git.diff();
+        expect(result.hasDiff).toBe(false);
+        expect(result.diffText.trim()).toBe('');
+        expect(result.stats.filesChanged).toBe(0);
+    });
+    it('reports diff when files are modified', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        const git = new GitOperations(dir);
+        const result = await git.diff();
+        expect(result.hasDiff).toBe(true);
+        expect(result.diffText).toContain('Changed');
+        expect(result.stats.filesChanged).toBe(1);
+        expect(result.stats.insertions).toBeGreaterThan(0);
+    });
+    it('commits all changes', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'new-file.ts'), 'export const x = 1;\n');
+        const git = new GitOperations(dir);
+        const result = await git.commit('add new file');
+        expect(result.success).toBe(true);
+        expect(result.output).toContain('add new file');
+        // Verify clean after commit
+        const diff = await git.diff();
+        expect(diff.hasDiff).toBe(false);
+    });
+    it('resets hard to discard changes', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        await writeFile(join(dir, 'untracked.ts'), 'junk');
+        const git = new GitOperations(dir);
+        const result = await git.resetHard();
+        expect(result.success).toBe(true);
+        const diff = await git.diff();
+        expect(diff.hasDiff).toBe(false);
+    });
+    it('returns current branch', async () => {
+        const dir = await createTestRepo();
+        const git = new GitOperations(dir);
+        const branch = await git.currentBranch();
+        // Could be 'main' or 'master' depending on git config
+        expect(branch.length).toBeGreaterThan(0);
+    });
+    it('returns recent commits', async () => {
+        const dir = await createTestRepo();
+        const git = new GitOperations(dir);
+        const log = await git.recentCommits(1);
+        expect(log).toContain('initial');
+    });
+    it('returns diffStat output', async () => {
+        const dir = await createTestRepo();
+        await writeFile(join(dir, 'README.md'), '# Changed\n');
+        const git = new GitOperations(dir);
+        const stat = await git.diffStat();
+        expect(stat).toContain('README.md');
+        expect(stat).toContain('changed');
+    });
+    it('handles commit failure on clean repo', async () => {
+        const dir = await createTestRepo();
+        const git = new GitOperations(dir);
+        const result = await git.commit('nothing to commit');
+        expect(result.success).toBe(false);
+        expect(result.error).toBeDefined();
+    });
+});

package/dist/test/persistent-manager.test.d.ts

@@ -0,0 +1 @@
+export {};