popeye-cli 1.10.0 → 2.1.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/bridges/review-bridge.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Review Bridge tests — severity mapping, category mapping, CR routing,
+ * pipeline detection, finding conversion.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  mapSeverity,
+  mapCategory,
+  categoryToChangeType,
+  convertFinding,
+  isPipelineManaged,
+  extractPipelineState,
+} from '../../../src/pipeline/bridges/review-bridge.js';
+import { createDefaultPipelineState } from '../../../src/pipeline/types.js';
+import type { AuditFinding as WorkflowFinding } from '../../../src/types/audit.js';
+import type { ArtifactRef } from '../../../src/pipeline/types.js';
+import type { ProjectState } from '../../../src/types/workflow.js';
+
+// ─── Test Data ───────────────────────────────────────────
+
+function makeSnapshotRef(): ArtifactRef {
+  return {
+    artifact_id: 'snap-001',
+    path: 'docs/snapshots/repo_snapshot_001.json',
+    sha256: 'abc123',
+    version: 1,
+    type: 'repo_snapshot',
+  };
+}
+
+function makeWorkflowFinding(overrides: Partial<WorkflowFinding> = {}): WorkflowFinding {
+  return {
+    id: 'finding-1',
+    category: 'integration-wiring',
+    severity: 'critical',
+    title: 'API endpoint mismatch',
+    description: 'Frontend calls /api/users but backend serves /api/v1/users',
+    evidence: [{ file: 'src/api.ts', line: 42, snippet: 'fetch("/api/users")' }],
+    recommendation: 'Update frontend API base URL',
+    autoFixable: true,
+    ...overrides,
+  };
+}
+
+function makeProjectState(withPipeline = false): ProjectState {
+  const base: ProjectState = {
+    id: 'test-id',
+    name: 'test-project',
+    idea: 'Build something',
+    language: 'python',
+    phase: 'execution',
+    status: 'in-progress',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as ProjectState;
+
+  if (withPipeline) {
+    (base as unknown as { pipeline: unknown }).pipeline = createDefaultPipelineState();
+  }
+
+  return base;
+}
+
+// ─── Tests ───────────────────────────────────────────────
+
+describe('Review Bridge', () => {
+  describe('severity mapping', () => {
+    it('should map critical to P0', () => {
+      expect(mapSeverity('critical')).toBe('P0');
+    });
+
+    it('should map major to P1', () => {
+      expect(mapSeverity('major')).toBe('P1');
+    });
+
+    it('should map minor to P2', () => {
+      expect(mapSeverity('minor')).toBe('P2');
+    });
+
+    it('should map info to P3', () => {
+      expect(mapSeverity('info')).toBe('P3');
+    });
+  });
+
+  describe('category mapping', () => {
+    it('should map integration-wiring to integration', () => {
+      expect(mapCategory('integration-wiring')).toBe('integration');
+    });
+
+    it('should map feature-completeness to integration', () => {
+      expect(mapCategory('feature-completeness')).toBe('integration');
+    });
+
+    it('should map test-coverage to tests', () => {
+      expect(mapCategory('test-coverage')).toBe('tests');
+    });
+
+    it('should map config-deployment to config', () => {
+      expect(mapCategory('config-deployment')).toBe('config');
+    });
+
+    it('should map security to security', () => {
+      expect(mapCategory('security')).toBe('security');
+    });
+
+    it('should map dependency-sanity to deployment', () => {
+      expect(mapCategory('dependency-sanity')).toBe('deployment');
+    });
+
+    it('should map consistency to schema', () => {
+      expect(mapCategory('consistency')).toBe('schema');
+    });
+
+    it('should map documentation to deployment', () => {
+      expect(mapCategory('documentation')).toBe('deployment');
+    });
+  });
+
+  describe('CR change type routing', () => {
+    it('should route integration to architecture CR', () => {
+      expect(categoryToChangeType('integration')).toBe('architecture');
+    });
+
+    it('should route schema to architecture CR', () => {
+      expect(categoryToChangeType('schema')).toBe('architecture');
+    });
+
+    it('should route security to requirement CR', () => {
+      expect(categoryToChangeType('security')).toBe('requirement');
+    });
+
+    it('should route tests to config CR', () => {
+      expect(categoryToChangeType('tests')).toBe('config');
+    });
+
+    it('should route config to config CR', () => {
+      expect(categoryToChangeType('config')).toBe('config');
+    });
+
+    it('should route deployment to config CR', () => {
+      expect(categoryToChangeType('deployment')).toBe('config');
+    });
+  });
+
+  describe('finding conversion', () => {
+    it('should convert a critical workflow finding to P0 pipeline finding', () => {
+      const wf = makeWorkflowFinding({ severity: 'critical', category: 'integration-wiring' });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.id).toBe('finding-1');
+      expect(pf.severity).toBe('P0');
+      expect(pf.category).toBe('integration');
+      expect(pf.blocking).toBe(true);
+      expect(pf.description).toContain('API endpoint mismatch');
+      expect(pf.file_path).toBe('src/api.ts');
+      expect(pf.line_number).toBe(42);
+      expect(pf.evidence).toEqual([ref]);
+      expect(pf.suggested_owner).toBe('AUDITOR');
+    });
+
+    it('should convert an info finding to P3 non-blocking', () => {
+      const wf = makeWorkflowFinding({ severity: 'info', category: 'documentation' });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.severity).toBe('P3');
+      expect(pf.blocking).toBe(false);
+    });
+
+    it('should mark P0 and P1 as blocking, P2 and P3 as non-blocking', () => {
+      const ref = makeSnapshotRef();
+
+      expect(convertFinding(makeWorkflowFinding({ severity: 'critical' }), ref).blocking).toBe(true);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'major' }), ref).blocking).toBe(true);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'minor' }), ref).blocking).toBe(false);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'info' }), ref).blocking).toBe(false);
+    });
+
+    it('should handle finding with no evidence', () => {
+      const wf = makeWorkflowFinding({ evidence: [] });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.file_path).toBeUndefined();
+      expect(pf.line_number).toBeUndefined();
+    });
+  });
+
+  describe('pipeline detection', () => {
+    it('should detect pipeline-managed state', () => {
+      const state = makeProjectState(true);
+      expect(isPipelineManaged(state)).toBe(true);
+    });
+
+    it('should detect non-pipeline state', () => {
+      const state = makeProjectState(false);
+      expect(isPipelineManaged(state)).toBe(false);
+    });
+
+    it('should extract pipeline state when present', () => {
+      const state = makeProjectState(true);
+      const pipeline = extractPipelineState(state);
+
+      expect(pipeline).toBeDefined();
+      expect(pipeline!.pipelinePhase).toBe('INTAKE');
+    });
+
+    it('should return undefined when no pipeline state', () => {
+      const state = makeProjectState(false);
+      expect(extractPipelineState(state)).toBeUndefined();
+    });
+  });
+
+  describe('CR routing determinism', () => {
+    it('should route integration findings to CONSENSUS_ARCHITECTURE', () => {
+      // Integration → architecture CR → CONSENSUS_ARCHITECTURE (via change-request.ts routing)
+      const changeType = categoryToChangeType('integration');
+      expect(changeType).toBe('architecture');
+      // architecture routes to CONSENSUS_ARCHITECTURE per CHANGE_TYPE_ROUTING
+    });
+
+    it('should route security findings to CONSENSUS_MASTER_PLAN', () => {
+      const changeType = categoryToChangeType('security');
+      expect(changeType).toBe('requirement');
+      // requirement routes to CONSENSUS_MASTER_PLAN per CHANGE_TYPE_ROUTING
+    });
+
+    it('should route test findings to QA_VALIDATION', () => {
+      const changeType = categoryToChangeType('tests');
+      expect(changeType).toBe('config');
+      // config routes to QA_VALIDATION per CHANGE_TYPE_ROUTING
+    });
+  });
+});

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');
+  });
+});