@assistkick/create 1.0.0

package/templates/product-system/tests/pipeline-unit.test.ts

@@ -0,0 +1,593 @@
+/**
+ * Unit tests for lib/pipeline.js with mocked dependencies.
+ * Uses node:test built-in runner + assert (matching existing test patterns).
+ */
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Pipeline } from '../packages/shared/lib/pipeline.js';
+import { PromptBuilder } from '../packages/shared/lib/prompt_builder.js';
+import { GitWorkflow } from '../packages/shared/lib/git_workflow.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILL_DIR = join(__dirname, '..');
+
+// --- Mock factories ---
+
+const createMockKanban = (initialEntries = {}) => {
+  const store = new Map(Object.entries(initialEntries));
+  return {
+    getKanbanEntry: async (id) => {
+      const entry = store.get(id);
+      // Return a deep copy so mutations don't affect the store directly
+      return entry ? JSON.parse(JSON.stringify(entry)) : null;
+    },
+    saveKanbanEntry: async (id, entry) => {
+      store.set(id, JSON.parse(JSON.stringify(entry)));
+    },
+    // Helper to read current state in assertions
+    _get: (id) => store.get(id),
+  };
+};
+
+const createMockClaudeService = (overrides = {}) => {
+  const calls = { spawnClaude: [], spawnCommand: [] };
+  return {
+    spawnClaude: overrides.spawnClaude || (async (prompt, cwd, label) => {
+      calls.spawnClaude.push({ prompt, cwd, label });
+      return 'mock output';
+    }),
+    spawnCommand: overrides.spawnCommand || (async (cmd, args, cwd) => {
+      calls.spawnCommand.push({ cmd, args, cwd });
+      return '';
+    }),
+    _calls: calls,
+  };
+};
+
+const mockPaths = {
+  projectRoot: '/mock/project',
+  worktreesDir: '/mock/worktrees',
+  skillsDir: join(SKILL_DIR, '..', '.claude', 'skills'),
+  toolsDir: join(SKILL_DIR, 'tools'),
+  dataDir: SKILL_DIR,
+  developerSkillPath: join(SKILL_DIR, '..', '.claude', 'skills', 'product-developer', 'SKILL.md'),
+  reviewerSkillPath: join(SKILL_DIR, '..', '.claude', 'skills', 'product-code-reviewer', 'SKILL.md'),
+  debuggerSkillPath: join(SKILL_DIR, '..', '.claude', 'skills', 'product-debugger', 'SKILL.md'),
+};
+
+const noop = () => {};
+
+/** Create a Pipeline instance with mock dependencies. */
+const createTestPipeline = (mockClaude, mockKanban) => {
+  const promptBuilder = new PromptBuilder({ paths: mockPaths, log: noop });
+  const gitWorkflow = new GitWorkflow({ claudeService: mockClaude, projectRoot: mockPaths.projectRoot, worktreesDir: mockPaths.worktreesDir, log: noop });
+  return new Pipeline({
+    promptBuilder,
+    gitWorkflow,
+    claudeService: mockClaude,
+    kanban: mockKanban,
+    paths: mockPaths,
+    log: noop,
+  });
+};
+
+// --- Tests ---
+
+describe('pipeline.start() validation', () => {
+  it('rejects if feature not found in kanban', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    const result = await pipeline.start('feat_999');
+    assert.equal(result.status, 404);
+    assert.ok(result.error.includes('feat_999'));
+  });
+
+  it('rejects if feature not in todo column', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'in_progress', rejection_count: 0, notes: [] },
+    });
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    const result = await pipeline.start('feat_010');
+    assert.equal(result.status, 400);
+    assert.ok(result.error.includes('todo'));
+  });
+
+  it('rejects if feature is dev_blocked', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'todo', rejection_count: 0, notes: [], dev_blocked: true },
+    });
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    const result = await pipeline.start('feat_010');
+    assert.equal(result.status, 400);
+    assert.ok(result.error.includes('dev_blocked'));
+  });
+
+  it('rejects if pipeline already running', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'todo', rejection_count: 0, notes: [] },
+    });
+    // spawnCommand succeeds for worktree creation, spawnClaude never resolves (simulates running)
+    const mockClaude = createMockClaudeService({
+      spawnClaude: () => new Promise(() => {}), // never resolves
+      spawnCommand: async () => '',
+    });
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    // First start succeeds
+    const result1 = await pipeline.start('feat_010');
+    assert.equal(result1.status, 200);
+
+    // Reset kanban to todo so it's not blocked by column check
+    await mockKanban.saveKanbanEntry('feat_010', { column: 'todo', rejection_count: 0, notes: [] });
+
+    // Second start should be rejected (pipeline still running)
+    const result2 = await pipeline.start('feat_010');
+    assert.equal(result2.status, 409);
+    assert.ok(result2.error.includes('already running'));
+  });
+});
+
+describe('pipeline.getStatus()', () => {
+  it('returns idle when no pipeline exists', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    const result = await pipeline.getStatus('feat_999');
+    assert.equal(result.status, 'idle');
+    assert.equal(result.feature_id, 'feat_999');
+  });
+});
+
+describe('pipeline.unblock()', () => {
+  it('returns 404 for unknown feature', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    const result = await pipeline.unblock('feat_999');
+    assert.equal(result.status, 404);
+  });
+
+  it('clears dev_blocked and pipeline state', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'todo', rejection_count: 3, notes: [], dev_blocked: true },
+    });
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    // Simulate a blocked pipeline state
+    pipeline.pipelines.set('feat_010', { status: 'blocked', cycle: 3 });
+
+    const result = await pipeline.unblock('feat_010');
+    assert.equal(result.status, 200);
+    assert.equal(result.unblocked, true);
+
+    // Verify dev_blocked is removed from kanban
+    const entry = mockKanban._get('feat_010');
+    assert.equal(entry.dev_blocked, undefined);
+
+    // Verify pipeline state is cleared
+    assert.equal(pipeline.pipelines.has('feat_010'), false);
+  });
+});
+
+describe('pipeline.run() — full cycle with reviewer approving', () => {
+  it('completes when reviewer moves card to qa', async () => {
+    let claudeCallCount = 0;
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'in_progress', rejection_count: 0, notes: [] },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label) => {
+        claudeCallCount++;
+        // When reviewer runs, move the card to qa
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          entry.column = 'qa';
+          entry.moved_at = new Date().toISOString();
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock output';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    // Set up pipeline state as if start() ran the setup
+    pipeline.pipelines.set('feat_010', { status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010', process: null, error: null });
+
+    await pipeline.run('feat_010');
+
+    const state = pipeline.pipelines.get('feat_010');
+    assert.equal(state.status, 'completed');
+    // Developer + Reviewer = 2 Claude calls
+    assert.equal(claudeCallCount, 2);
+  });
+});
+
+describe('pipeline.run() — reviewer rejecting 3x causes block', () => {
+  it('blocks card after 3 rejected cycles', async () => {
+    let claudeCallCount = 0;
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'in_progress', rejection_count: 0, notes: [] },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label) => {
+        claudeCallCount++;
+        // Reviewer always rejects — moves card to todo
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          entry.column = 'todo';
+          entry.moved_at = new Date().toISOString();
+          entry.notes = [{ id: 'n1', text: 'Needs fixes' }];
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock output';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', { status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010', process: null, error: null });
+
+    await pipeline.run('feat_010');
+
+    const state = pipeline.pipelines.get('feat_010');
+    assert.equal(state.status, 'blocked');
+
+    // 3 cycles × (dev + reviewer) = 6 Claude calls
+    assert.equal(claudeCallCount, 6);
+
+    // Kanban entry should be dev_blocked
+    const entry = mockKanban._get('feat_010');
+    assert.equal(entry.dev_blocked, true);
+  });
+});
+
+describe('pipeline.run() — debug-first step', () => {
+  it('runs debugger when unaddressed notes exist', async () => {
+    const claudeCalls = [];
+    const mockKanban = createMockKanban({
+      feat_010: {
+        column: 'in_progress',
+        rejection_count: 1,
+        notes: [
+          { id: 'n1', text: 'Bug: missing validation', addressed: false },
+          { id: 'n2', text: 'Bug: wrong color', addressed: true },
+        ],
+      },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label) => {
+        claudeCalls.push(label);
+        // Reviewer approves on first cycle
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          entry.column = 'qa';
+          entry.moved_at = new Date().toISOString();
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock debugger findings';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', { status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010', process: null, error: null });
+
+    await pipeline.run('feat_010');
+
+    // First call should be the debugger
+    assert.equal(claudeCalls[0], 'debug:feat_010');
+    // Then developer, then reviewer
+    assert.equal(claudeCalls[1], 'dev:feat_010');
+    assert.equal(claudeCalls[2], 'review:feat_010');
+
+    // The unaddressed note should now be marked as addressed
+    const entry = mockKanban._get('feat_010');
+    const note = entry.notes.find(n => n.id === 'n1');
+    assert.equal(note.addressed, true);
+  });
+
+  it('skips debugger when all notes are already addressed', async () => {
+    const claudeCalls = [];
+    const mockKanban = createMockKanban({
+      feat_010: {
+        column: 'in_progress',
+        rejection_count: 1,
+        notes: [
+          { id: 'n1', text: 'Bug: fixed', addressed: true },
+        ],
+      },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label) => {
+        claudeCalls.push(label);
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          entry.column = 'qa';
+          entry.moved_at = new Date().toISOString();
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock output';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', { status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010', process: null, error: null });
+
+    await pipeline.run('feat_010');
+
+    // No debugger call — first call should be developer
+    assert.equal(claudeCalls[0], 'dev:feat_010');
+    assert.equal(claudeCalls.length, 2); // dev + reviewer only
+  });
+});
+
+describe('pipeline task progress tracking', () => {
+  it('initializes tasks field in pipeline state on start', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'todo', rejection_count: 0, notes: [] },
+    });
+    const mockClaude = createMockClaudeService({
+      spawnClaude: () => new Promise(() => {}), // never resolves
+      spawnCommand: async () => '',
+    });
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    await pipeline.start('feat_010');
+
+    const state = pipeline.pipelines.get('feat_010');
+    assert.deepEqual(state.tasks, { completed: 0, total: 0, items: [] });
+  });
+
+  it('resets tasks at the start of each cycle', async () => {
+    let claudeCallCount = 0;
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'in_progress', rejection_count: 0, notes: [] },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label, opts) => {
+        claudeCallCount++;
+        if (label.startsWith('dev:')) {
+          // Simulate TodoWrite callback if present
+          if (opts?.onToolUse) {
+            opts.onToolUse('TodoWrite', {
+              todos: [
+                { content: 'Task A', status: 'completed', activeForm: 'Doing A' },
+                { content: 'Task B', status: 'in_progress', activeForm: 'Doing B' },
+              ],
+            });
+          }
+        }
+        // Reviewer rejects on first cycle, approves on second
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          if (claudeCallCount <= 2) {
+            entry.column = 'todo';
+            entry.notes = [{ id: 'n1', text: 'Fix it' }];
+          } else {
+            entry.column = 'qa';
+          }
+          entry.moved_at = new Date().toISOString();
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock output';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010',
+      process: null, error: null, tasks: { completed: 0, total: 0, items: [] },
+    });
+
+    await pipeline.run('feat_010');
+
+    // Pipeline should have completed after 2 cycles
+    const state = pipeline.pipelines.get('feat_010');
+    assert.equal(state.status, 'completed');
+  });
+
+  it('getStatus includes tasks when total > 0', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock',
+      process: null, error: null,
+      tasks: { completed: 3, total: 7, items: [
+        { name: 'Task A', status: 'completed' },
+        { name: 'Task B', status: 'completed' },
+        { name: 'Task C', status: 'completed' },
+        { name: 'Task D', status: 'in_progress' },
+        { name: 'Task E', status: 'pending' },
+        { name: 'Task F', status: 'pending' },
+        { name: 'Task G', status: 'pending' },
+      ] },
+    });
+
+    const result = await pipeline.getStatus('feat_010');
+    assert.equal(result.tasks.completed, 3);
+    assert.equal(result.tasks.total, 7);
+    assert.equal(result.tasks.items.length, 7);
+  });
+
+  it('getStatus omits tasks when total is 0', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock',
+      process: null, error: null,
+      tasks: { completed: 0, total: 0, items: [] },
+    });
+
+    const result = await pipeline.getStatus('feat_010');
+    assert.equal(result.tasks, undefined);
+  });
+});
+
+describe('pipeline tool call activity counters', () => {
+  it('initializes toolCalls field in pipeline state on start', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'todo', rejection_count: 0, notes: [] },
+    });
+    const mockClaude = createMockClaudeService({
+      spawnClaude: () => new Promise(() => {}),
+      spawnCommand: async () => '',
+    });
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    await pipeline.start('feat_010');
+
+    const state = pipeline.pipelines.get('feat_010');
+    assert.deepEqual(state.toolCalls, { total: 0, write: 0, edit: 0, read: 0, bash: 0 });
+  });
+
+  it('counts tool calls by type via onToolUse callback', async () => {
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'in_progress', rejection_count: 0, notes: [] },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label, opts) => {
+        if (label.startsWith('dev:') && opts?.onToolUse) {
+          opts.onToolUse('Read', { file_path: '/some/file.js' });
+          opts.onToolUse('Read', { file_path: '/another/file.js' });
+          opts.onToolUse('Edit', { file_path: '/some/file.js', old_string: 'a', new_string: 'b' });
+          opts.onToolUse('Write', { file_path: '/new/file.js', content: '...' });
+          opts.onToolUse('Bash', { command: 'npm test' });
+          opts.onToolUse('Bash', { command: 'ls' });
+          opts.onToolUse('TodoWrite', { todos: [{ content: 'Task', status: 'pending', activeForm: 'Doing' }] });
+          opts.onToolUse('Grep', { pattern: 'foo' });
+        }
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          entry.column = 'qa';
+          entry.moved_at = new Date().toISOString();
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock output';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010',
+      process: null, error: null,
+      tasks: { completed: 0, total: 0, items: [] },
+      toolCalls: { total: 0, write: 0, edit: 0, read: 0, bash: 0 },
+    });
+
+    await pipeline.run('feat_010');
+
+    const state = pipeline.pipelines.get('feat_010');
+    assert.equal(state.toolCalls.total, 8);
+    assert.equal(state.toolCalls.read, 2);
+    assert.equal(state.toolCalls.edit, 1);
+    assert.equal(state.toolCalls.write, 1);
+    assert.equal(state.toolCalls.bash, 2);
+  });
+
+  it('resets toolCalls at the start of each cycle', async () => {
+    let claudeCallCount = 0;
+    const mockKanban = createMockKanban({
+      feat_010: { column: 'in_progress', rejection_count: 0, notes: [] },
+    });
+
+    const mockClaude = createMockClaudeService({
+      spawnClaude: async (prompt, cwd, label, opts) => {
+        claudeCallCount++;
+        if (label.startsWith('dev:') && opts?.onToolUse) {
+          opts.onToolUse('Write', { file_path: '/f.js', content: '...' });
+          opts.onToolUse('Edit', { file_path: '/f.js', old_string: 'a', new_string: 'b' });
+        }
+        if (label.startsWith('review:')) {
+          const entry = await mockKanban.getKanbanEntry('feat_010');
+          if (claudeCallCount <= 2) {
+            entry.column = 'todo';
+            entry.notes = [{ id: 'n1', text: 'Fix' }];
+          } else {
+            entry.column = 'qa';
+          }
+          entry.moved_at = new Date().toISOString();
+          await mockKanban.saveKanbanEntry('feat_010', entry);
+        }
+        return 'mock output';
+      },
+      spawnCommand: async () => '',
+    });
+
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock/worktrees/feat_010',
+      process: null, error: null,
+      tasks: { completed: 0, total: 0, items: [] },
+      toolCalls: { total: 0, write: 0, edit: 0, read: 0, bash: 0 },
+    });
+
+    await pipeline.run('feat_010');
+
+    // After 2 cycles (reject + approve), toolCalls should reflect only cycle 2
+    const state = pipeline.pipelines.get('feat_010');
+    assert.equal(state.toolCalls.total, 2);
+    assert.equal(state.toolCalls.write, 1);
+    assert.equal(state.toolCalls.edit, 1);
+  });
+
+  it('getStatus includes toolCalls when total > 0', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock',
+      process: null, error: null,
+      tasks: { completed: 0, total: 0, items: [] },
+      toolCalls: { total: 5, write: 1, edit: 2, read: 1, bash: 1 },
+    });
+
+    const result = await pipeline.getStatus('feat_010');
+    assert.deepEqual(result.toolCalls, { total: 5, write: 1, edit: 2, read: 1, bash: 1 });
+  });
+
+  it('getStatus omits toolCalls when total is 0', async () => {
+    const mockKanban = createMockKanban({});
+    const mockClaude = createMockClaudeService();
+    const pipeline = createTestPipeline(mockClaude, mockKanban);
+
+    pipeline.pipelines.set('feat_010', {
+      status: 'developing', cycle: 1, worktree_path: '/mock',
+      process: null, error: null,
+      tasks: { completed: 0, total: 0, items: [] },
+      toolCalls: { total: 0, write: 0, edit: 0, read: 0, bash: 0 },
+    });
+
+    const result = await pipeline.getStatus('feat_010');
+    assert.equal(result.toolCalls, undefined);
+  });
+});