popeye-cli 1.10.0 → 2.0.0

package/tests/pipeline/artifact-validators.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Artifact Validators tests — completeness checks for each artifact type.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateArtifactCompleteness,
+  getValidatableArtifactTypes,
+} from '../../src/pipeline/artifact-validators.js';
+
+describe('validateArtifactCompleteness', () => {
+  describe('master_plan', () => {
+    it('should pass for complete master plan', () => {
+      const content = [
+        '# Master Plan',
+        '## Goals',
+        'Build a comprehensive todo application with real-time sync capabilities.',
+        'The application should support multiple users and collaborative editing features.',
+        '## Milestones',
+        'Milestone 1: Setup project structure, install dependencies, configure CI/CD pipeline',
+        'Milestone 2: Core features including task CRUD, real-time updates, and user auth',
+        '## Success Criteria',
+        'All tests pass with 80% coverage, app deploys successfully to production environment.',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('master_plan', content);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should fail for empty content', () => {
+      const result = validateArtifactCompleteness('master_plan', '');
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('empty content');
+    });
+
+    it('should fail for too-short content', () => {
+      const result = validateArtifactCompleteness('master_plan', '# Plan\nGoals: TBD');
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('too short'))).toBe(true);
+    });
+
+    it('should fail when missing Goals section', () => {
+      const content = [
+        '# Master Plan',
+        'Some text that is long enough to pass the minimum length check.',
+        '## Milestones',
+        'Milestone 1: Setup project structure and dependencies.',
+        '## Success Criteria',
+        'All tests pass and the application deploys.',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('master_plan', content);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('Goals'))).toBe(true);
+    });
+
+    it('should fail when missing Milestones section', () => {
+      const content = [
+        '# Master Plan',
+        '## Goals',
+        'Build a comprehensive todo application with real-time sync.',
+        'The application should support multiple users.',
+        '## Success Criteria',
+        'All tests pass and the application deploys successfully.',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('master_plan', content);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('Milestones'))).toBe(true);
+    });
+  });
+
+  describe('architecture', () => {
+    it('should pass for complete architecture', () => {
+      const content = [
+        '# Architecture',
+        '## Components',
+        'Frontend: React SPA in src/app/ with component-based architecture using TypeScript.',
+        'Backend: FastAPI in src/server/ with layered architecture (routes, services, models).',
+        '## Data Flow',
+        'REST API contracts between FE and BE, with JSON payloads and OpenAPI specification.',
+        '## Tech Stack',
+        'React 18, TypeScript 5.x, FastAPI 0.100+, PostgreSQL 15, Redis for caching.',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('architecture', content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should fail when missing components section', () => {
+      const content = [
+        '# Architecture',
+        'Some long enough content for the min length check.',
+        '## Data Flow',
+        'REST API between FE and BE using src/api/ routes.',
+        '## Tech Stack',
+        'React, TypeScript, FastAPI',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('architecture', content);
+      expect(result.valid).toBe(false);
+    });
+
+    it('should warn when no file paths referenced', () => {
+      const content = [
+        '# Architecture',
+        '## Components',
+        'Frontend and Backend modules communicating via REST protocol for data exchange.',
+        'The component architecture follows a modular design pattern with clear separation.',
+        '## Contracts',
+        'JSON-based API contracts define the interface between all system components clearly.',
+        '## Tech Stack',
+        'React for the frontend, TypeScript for type safety, and a backend runtime environment.',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('architecture', content);
+      expect(result.warnings.some((w) => w.includes('file path'))).toBe(true);
+    });
+  });
+
+  describe('role_plan', () => {
+    it('should pass for complete role plan', () => {
+      const content = [
+        '# FRONTEND_PROGRAMMER Role Plan',
+        '## Tasks',
+        '- Build login page',
+        '- Implement dashboard',
+        '## Dependencies',
+        'Requires API contracts from BACKEND_PROGRAMMER.',
+        '## Acceptance Criteria',
+        'All pages render, tests pass.',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('role_plan', content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should fail for too-short role plan', () => {
+      const result = validateArtifactCompleteness('role_plan', '# Plan');
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('qa_validation', () => {
+    it('should pass with test results and coverage', () => {
+      const content = [
+        '# QA Validation',
+        '## Test Results',
+        '45 tests passing, 0 failing',
+        '## Coverage',
+        'Overall coverage: 87%',
+      ].join('\n');
+
+      const result = validateArtifactCompleteness('qa_validation', content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should fail without test results section', () => {
+      const content = '# QA\n## Coverage\n80% coverage';
+      const result = validateArtifactCompleteness('qa_validation', content);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('audit_report (JSON)', () => {
+    it('should pass for valid JSON audit report', () => {
+      const content = JSON.stringify({
+        findings: [{ id: '1', severity: 'P2' }],
+        overall_status: 'PASS',
+        system_risk_score: 25,
+      });
+
+      const result = validateArtifactCompleteness('audit_report', content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should fail when missing findings array', () => {
+      const content = JSON.stringify({
+        overall_status: 'PASS',
+        system_risk_score: 25,
+      });
+
+      const result = validateArtifactCompleteness('audit_report', content);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('unknown artifact types', () => {
+    it('should pass for artifact types without validators', () => {
+      const result = validateArtifactCompleteness('release_notes', 'Any content');
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('getValidatableArtifactTypes', () => {
+    it('should return artifact types with registered validators', () => {
+      const types = getValidatableArtifactTypes();
+      expect(types).toContain('master_plan');
+      expect(types).toContain('architecture');
+      expect(types).toContain('role_plan');
+      expect(types).toContain('qa_validation');
+      expect(types).toContain('audit_report');
+      expect(types.length).toBe(5);
+    });
+  });
+});

package/tests/pipeline/change-request.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Change Request tests — builder, routing, formatting.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  buildChangeRequest,
+  routeChangeRequest,
+  formatChangeRequest,
+} from '../../src/pipeline/change-request.js';
+import type { ArtifactRef } from '../../src/pipeline/types.js';
+
+const mockRef: ArtifactRef = {
+  artifact_id: 'test-artifact',
+  path: 'docs/test.md',
+  sha256: 'abc',
+  version: 1,
+  type: 'repo_snapshot',
+};
+
+describe('buildChangeRequest', () => {
+  it('should create a CR with generated ID and timestamp', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'REVIEW',
+      requestedBy: 'REVIEWER',
+      changeType: 'config',
+      description: 'Config files changed',
+      justification: 'Drift detected',
+      affectedArtifacts: [mockRef],
+      affectedPhases: ['IMPLEMENTATION'],
+      riskLevel: 'medium',
+    });
+
+    expect(cr.cr_id).toMatch(/^CR-/);
+    expect(cr.timestamp).toBeTruthy();
+    expect(cr.status).toBe('proposed');
+    expect(cr.origin_phase).toBe('REVIEW');
+    expect(cr.requested_by).toBe('REVIEWER');
+    expect(cr.change_type).toBe('config');
+    expect(cr.impact_analysis.risk_level).toBe('medium');
+  });
+
+  it('should generate unique IDs for different CRs', () => {
+    const cr1 = buildChangeRequest({
+      originPhase: 'AUDIT',
+      requestedBy: 'AUDITOR',
+      changeType: 'architecture',
+      description: 'Arch change',
+      justification: 'Finding',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'high',
+    });
+    const cr2 = buildChangeRequest({
+      originPhase: 'AUDIT',
+      requestedBy: 'AUDITOR',
+      changeType: 'scope',
+      description: 'Scope change',
+      justification: 'Finding 2',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'low',
+    });
+
+    expect(cr1.cr_id).not.toBe(cr2.cr_id);
+  });
+
+  it('should include impact analysis', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'REVIEW',
+      requestedBy: 'REVIEWER',
+      changeType: 'scope',
+      description: 'Scope expanded',
+      justification: 'New requirements',
+      affectedArtifacts: [mockRef],
+      affectedPhases: ['CONSENSUS_MASTER_PLAN', 'IMPLEMENTATION'],
+      riskLevel: 'high',
+    });
+
+    expect(cr.impact_analysis.affected_artifacts).toHaveLength(1);
+    expect(cr.impact_analysis.affected_phases).toContain('CONSENSUS_MASTER_PLAN');
+    expect(cr.impact_analysis.risk_level).toBe('high');
+  });
+});
+
+describe('routeChangeRequest', () => {
+  it('should route scope changes to CONSENSUS_MASTER_PLAN', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'REVIEW',
+      requestedBy: 'REVIEWER',
+      changeType: 'scope',
+      description: 'test',
+      justification: 'test',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'low',
+    });
+    expect(routeChangeRequest(cr)).toBe('CONSENSUS_MASTER_PLAN');
+  });
+
+  it('should route architecture changes to CONSENSUS_ARCHITECTURE', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'AUDIT',
+      requestedBy: 'AUDITOR',
+      changeType: 'architecture',
+      description: 'test',
+      justification: 'test',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'high',
+    });
+    expect(routeChangeRequest(cr)).toBe('CONSENSUS_ARCHITECTURE');
+  });
+
+  it('should route dependency changes to CONSENSUS_ROLE_PLANS', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'REVIEW',
+      requestedBy: 'REVIEWER',
+      changeType: 'dependency',
+      description: 'test',
+      justification: 'test',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'medium',
+    });
+    expect(routeChangeRequest(cr)).toBe('CONSENSUS_ROLE_PLANS');
+  });
+
+  it('should route config changes to QA_VALIDATION', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'REVIEW',
+      requestedBy: 'REVIEWER',
+      changeType: 'config',
+      description: 'test',
+      justification: 'test',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'low',
+    });
+    expect(routeChangeRequest(cr)).toBe('QA_VALIDATION');
+  });
+
+  it('should route requirement changes to CONSENSUS_MASTER_PLAN', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'AUDIT',
+      requestedBy: 'AUDITOR',
+      changeType: 'requirement',
+      description: 'test',
+      justification: 'test',
+      affectedArtifacts: [],
+      affectedPhases: [],
+      riskLevel: 'high',
+    });
+    expect(routeChangeRequest(cr)).toBe('CONSENSUS_MASTER_PLAN');
+  });
+});
+
+describe('formatChangeRequest', () => {
+  it('should format CR as markdown', () => {
+    const cr = buildChangeRequest({
+      originPhase: 'REVIEW',
+      requestedBy: 'REVIEWER',
+      changeType: 'config',
+      description: 'Config files changed during implementation',
+      justification: 'Detected by snapshot diff',
+      affectedArtifacts: [mockRef],
+      affectedPhases: ['IMPLEMENTATION'],
+      riskLevel: 'medium',
+    });
+
+    const md = formatChangeRequest(cr);
+    expect(md).toContain('# Change Request');
+    expect(md).toContain(cr.cr_id);
+    expect(md).toContain('proposed');
+    expect(md).toContain('config');
+    expect(md).toContain('REVIEWER');
+    expect(md).toContain('medium');
+    expect(md).toContain('Config files changed');
+  });
+});

package/tests/pipeline/check-runner.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Check Runner tests — sanitization, timeout, result capture, placeholder scan.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runCheck, runAllChecks, runPlaceholderScan } from '../../src/pipeline/check-runner.js';
+
+const TEST_DIR = join(process.cwd(), '.test-check-runner');
+
+describe('CheckRunner', () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  describe('runCheck', () => {
+    it('should return pass for successful commands', async () => {
+      const result = await runCheck('test', 'echo "ok"', TEST_DIR);
+      expect(result.check_type).toBe('test');
+      expect(result.status).toBe('pass');
+      expect(result.exit_code).toBe(0);
+      expect(result.duration_ms).toBeGreaterThanOrEqual(0);
+      expect(result.timestamp).toBeDefined();
+    });
+
+    it('should return fail for unsuccessful commands', async () => {
+      const result = await runCheck('build', 'exit 1', TEST_DIR);
+      expect(result.status).toBe('fail');
+      expect(result.exit_code).not.toBe(0);
+    });
+
+    it('should reject dangerous commands', async () => {
+      const result = await runCheck('test', 'rm -rf /', TEST_DIR);
+      expect(result.status).toBe('fail');
+      expect(result.exit_code).toBe(-1);
+      expect(result.stderr_summary).toContain('Command rejected');
+    });
+
+    it('should reject sudo commands', async () => {
+      const result = await runCheck('build', 'sudo apt install something', TEST_DIR);
+      expect(result.status).toBe('fail');
+      expect(result.stderr_summary).toContain('Command rejected');
+    });
+
+    it('should respect timeout', async () => {
+      const result = await runCheck('test', 'sleep 10', TEST_DIR, 500);
+      // Should either timeout or be killed
+      expect(result.status).toBe('fail');
+    }, 10000);
+
+    it('should capture stderr summary', async () => {
+      const result = await runCheck('lint', 'echo "error" >&2 && exit 1', TEST_DIR);
+      expect(result.status).toBe('fail');
+      expect(result.stderr_summary).toContain('error');
+    });
+  });
+
+  describe('runAllChecks', () => {
+    it('should run all provided commands', async () => {
+      const results = await runAllChecks({
+        build: 'echo "build ok"',
+        test: 'echo "test ok"',
+        lint: 'echo "lint ok"',
+        resolved_from: 'test',
+      }, TEST_DIR);
+
+      expect(results.length).toBe(5); // build, test, lint, typecheck(skip), migration(skip)
+      expect(results.filter((r) => r.status === 'pass')).toHaveLength(3);
+      expect(results.filter((r) => r.status === 'skip')).toHaveLength(2);
+    });
+
+    it('should skip missing commands', async () => {
+      const results = await runAllChecks({
+        resolved_from: 'test',
+      }, TEST_DIR);
+
+      expect(results.every((r) => r.status === 'skip')).toBe(true);
+    });
+  });
+
+  describe('runPlaceholderScan', () => {
+    it('should detect TODO in source files', () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, 'src', 'app.ts'),
+        '// TODO: implement this\nconst x = 1;\n',
+      );
+
+      const result = runPlaceholderScan(TEST_DIR);
+      expect(result.status).toBe('fail');
+      expect(result.check_type).toBe('placeholder_scan');
+      expect(result.stderr_summary).toContain('TODO');
+    });
+
+    it('should detect FIXME in source files', () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, 'src', 'util.ts'),
+        'const value = 0; // FIXME: broken\n',
+      );
+
+      const result = runPlaceholderScan(TEST_DIR);
+      expect(result.status).toBe('fail');
+      expect(result.stderr_summary).toContain('FIXME');
+    });
+
+    it('should detect lorem ipsum', () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, 'src', 'page.tsx'),
+        'const text = "Lorem ipsum dolor sit amet";\n',
+      );
+
+      const result = runPlaceholderScan(TEST_DIR);
+      expect(result.status).toBe('fail');
+    });
+
+    it('should pass when no placeholders found', () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, 'src', 'clean.ts'),
+        'export function add(a: number, b: number): number {\n  return a + b;\n}\n',
+      );
+
+      const result = runPlaceholderScan(TEST_DIR);
+      expect(result.status).toBe('pass');
+      expect(result.exit_code).toBe(0);
+    });
+
+    it('should respect allowlist', () => {
+      mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
+      writeFileSync(
+        join(TEST_DIR, 'src', 'app.ts'),
+        '// TODO: allowed\n',
+      );
+      writeFileSync(
+        join(TEST_DIR, '.popeye-placeholder-allowlist'),
+        'src/app.ts\n',
+      );
+
+      const result = runPlaceholderScan(TEST_DIR);
+      expect(result.status).toBe('pass');
+    });
+
+    it('should handle missing scan directories gracefully', () => {
+      // No src, app, pages, etc. directories
+      const result = runPlaceholderScan(TEST_DIR);
+      expect(result.status).toBe('pass');
+    });
+  });
+});