popeye-cli 2.1.0 → 2.7.0

package/tests/pipeline/skills/role-map.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Role map tests — role selection, tech stack inference, template constraints.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  getActiveRoles,
+  inferTechStack,
+  getTemplateConstraints,
+  SUPPORT_ROLES,
+  IMPLEMENTATION_ROLES,
+} from '../../../src/pipeline/skills/role-map.js';
+import type { RepoSnapshot } from '../../../src/pipeline/types.js';
+import type { OutputLanguage } from '../../../src/types/project.js';
+
+function makeSnapshot(overrides: Partial<RepoSnapshot> = {}): RepoSnapshot {
+  return {
+    snapshot_id: 'test-snap',
+    timestamp: new Date().toISOString(),
+    tree_summary: '',
+    config_files: [],
+    languages_detected: [],
+    scripts: {},
+    env_files: [],
+    migrations_present: false,
+    ports_entrypoints: [],
+    total_files: 0,
+    total_lines: 0,
+    ...overrides,
+  };
+}
+
+describe('role-map', () => {
+  describe('getActiveRoles', () => {
+    it('should include support roles for all languages', () => {
+      const languages: OutputLanguage[] = ['python', 'typescript', 'fullstack', 'website', 'all'];
+      for (const lang of languages) {
+        const roles = getActiveRoles(lang);
+        for (const support of SUPPORT_ROLES) {
+          expect(roles).toContain(support);
+        }
+      }
+    });
+
+    it('should include DB_EXPERT for python', () => {
+      const roles = getActiveRoles('python');
+      expect(roles).toContain('DB_EXPERT');
+      expect(roles).toContain('BACKEND_PROGRAMMER');
+      expect(roles).not.toContain('FRONTEND_PROGRAMMER');
+    });
+
+    it('should include FRONTEND_PROGRAMMER for typescript (not BACKEND_PROGRAMMER)', () => {
+      const roles = getActiveRoles('typescript');
+      expect(roles).toContain('FRONTEND_PROGRAMMER');
+      expect(roles).toContain('UI_UX_SPECIALIST');
+      expect(roles).not.toContain('BACKEND_PROGRAMMER');
+      expect(roles).not.toContain('DB_EXPERT');
+    });
+
+    it('should include both FE and BE for fullstack', () => {
+      const roles = getActiveRoles('fullstack');
+      expect(roles).toContain('DB_EXPERT');
+      expect(roles).toContain('BACKEND_PROGRAMMER');
+      expect(roles).toContain('FRONTEND_PROGRAMMER');
+      expect(roles).toContain('UI_UX_SPECIALIST');
+      expect(roles).not.toContain('WEBSITE_PROGRAMMER');
+    });
+
+    it('should include website and marketing roles for website', () => {
+      const roles = getActiveRoles('website');
+      expect(roles).toContain('WEBSITE_PROGRAMMER');
+      expect(roles).toContain('UI_UX_SPECIALIST');
+      expect(roles).toContain('MARKETING_EXPERT');
+      expect(roles).toContain('SOCIAL_EXPERT');
+      expect(roles).not.toContain('BACKEND_PROGRAMMER');
+    });
+
+    it('should include all implementation roles for all', () => {
+      const roles = getActiveRoles('all');
+      for (const impl of IMPLEMENTATION_ROLES) {
+        expect(roles).toContain(impl);
+      }
+    });
+  });
+
+  describe('inferTechStack', () => {
+    it('should return language defaults when no signals', () => {
+      const ts = inferTechStack('python');
+      expect(ts.backend).toBe('FastAPI');
+      expect(ts.database).toBe('PostgreSQL');
+      expect(ts.orm).toBe('SQLAlchemy');
+      expect(ts.testing).toBe('Pytest');
+      expect(ts.language).toBe('Python 3.11+');
+    });
+
+    it('should detect FastAPI from snapshot key_fields', () => {
+      const snapshot = makeSnapshot({
+        config_files: [{
+          path: 'pyproject.toml',
+          type: 'toml',
+          content_hash: 'abc',
+          key_fields: { dependencies: ['fastapi', 'uvicorn'] },
+        }],
+      });
+      const ts = inferTechStack('python', snapshot);
+      expect(ts.backend).toBe('FastAPI');
+    });
+
+    it('should detect Django from snapshot key_fields', () => {
+      const snapshot = makeSnapshot({
+        config_files: [{
+          path: 'requirements.txt',
+          type: 'txt',
+          content_hash: 'abc',
+          key_fields: { packages: ['django', 'django-rest-framework'] },
+        }],
+      });
+      const ts = inferTechStack('python', snapshot);
+      expect(ts.backend).toBe('Django');
+    });
+
+    it('should detect framework from expanded spec when snapshot has no deps', () => {
+      const ts = inferTechStack('python', makeSnapshot(), 'Build a Django REST API');
+      expect(ts.backend).toBe('Django');
+    });
+
+    it('should prioritize snapshot over spec mentions', () => {
+      const snapshot = makeSnapshot({
+        config_files: [{
+          path: 'pyproject.toml',
+          type: 'toml',
+          content_hash: 'abc',
+          key_fields: { dependencies: ['fastapi'] },
+        }],
+      });
+      const ts = inferTechStack('python', snapshot, 'Build a Django API');
+      // Snapshot has fastapi, spec mentions Django — snapshot wins
+      expect(ts.backend).toBe('FastAPI');
+    });
+
+    it('should return typescript defaults', () => {
+      const ts = inferTechStack('typescript');
+      expect(ts.frontend).toBe('React + Vite');
+      expect(ts.testing).toBe('Vitest');
+      expect(ts.language).toBe('TypeScript 5.x');
+    });
+
+    it('should detect Next.js from snapshot', () => {
+      const snapshot = makeSnapshot({
+        config_files: [{
+          path: 'package.json',
+          type: 'json',
+          content_hash: 'abc',
+          key_fields: { dependencies: { next: '^14.0.0', react: '^18.0.0' } },
+        }],
+      });
+      const ts = inferTechStack('typescript', snapshot);
+      expect(ts.frontend).toBe('Next.js');
+    });
+  });
+
+  describe('getTemplateConstraints', () => {
+    it('should always include governance constraints', () => {
+      const constraints = getTemplateConstraints('BACKEND_PROGRAMMER', {});
+      expect(constraints).toContain('must_follow_master_plan');
+      expect(constraints).toContain('must_follow_architecture');
+      expect(constraints).toContain('conflicts_require_change_request');
+    });
+
+    it('should add FastAPI constraints for backend with FastAPI', () => {
+      const constraints = getTemplateConstraints('BACKEND_PROGRAMMER', {
+        backend: 'FastAPI',
+        testing: 'Pytest',
+      });
+      expect(constraints).toContain('fastapi_async_required');
+      expect(constraints).toContain('pydantic_validation');
+      expect(constraints).toContain('pytest_testing');
+    });
+
+    it('should add React constraints for frontend', () => {
+      const constraints = getTemplateConstraints('FRONTEND_PROGRAMMER', {
+        frontend: 'React + Vite',
+        testing: 'Vitest',
+      });
+      expect(constraints).toContain('react_component_pattern');
+      expect(constraints).toContain('component_testing');
+    });
+
+    it('should return only governance constraints for roles without tech constraints', () => {
+      const constraints = getTemplateConstraints('DISPATCHER', {});
+      expect(constraints).toEqual([
+        'must_follow_master_plan',
+        'must_follow_architecture',
+        'conflicts_require_change_request',
+      ]);
+    });
+  });
+});

package/tests/pipeline/skills/usage-registry.test.ts

@@ -0,0 +1,114 @@
+/**
+ * SkillUsageRegistry tests — recording, querying, and array reference sharing.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SkillUsageRegistry } from '../../../src/pipeline/skills/usage-registry.js';
+import type { SkillUsageEvent } from '../../../src/pipeline/skills/usage-registry.js';
+
+describe('SkillUsageRegistry', () => {
+  let events: SkillUsageEvent[];
+  let registry: SkillUsageRegistry;
+
+  beforeEach(() => {
+    events = [];
+    registry = new SkillUsageRegistry(events);
+  });
+
+  describe('record', () => {
+    it('should record a usage event with all fields', () => {
+      registry.record('ARCHITECT', 'ARCHITECTURE', 'system_prompt', 'defaults', '1.0');
+
+      const recorded = registry.getEvents();
+      expect(recorded).toHaveLength(1);
+      expect(recorded[0].role).toBe('ARCHITECT');
+      expect(recorded[0].phase).toBe('ARCHITECTURE');
+      expect(recorded[0].used_as).toBe('system_prompt');
+      expect(recorded[0].skill_source).toBe('defaults');
+      expect(recorded[0].skill_version).toBe('1.0');
+      expect(recorded[0].timestamp).toBeTruthy();
+    });
+
+    it('should record event without optional version', () => {
+      registry.record('REVIEWER', 'REVIEW', 'review_prompt', 'project_override');
+
+      const recorded = registry.getEvents();
+      expect(recorded).toHaveLength(1);
+      expect(recorded[0].skill_version).toBeUndefined();
+    });
+
+    it('should push into the shared array reference', () => {
+      registry.record('AUDITOR', 'AUDIT', 'system_prompt', 'defaults');
+
+      // The underlying events array should be mutated directly
+      expect(events).toHaveLength(1);
+      expect(events[0].role).toBe('AUDITOR');
+    });
+  });
+
+  describe('getEvents', () => {
+    it('should return a copy of events', () => {
+      registry.record('ARCHITECT', 'ARCHITECTURE', 'system_prompt', 'defaults');
+      const copy = registry.getEvents();
+
+      // Mutating the copy should not affect the original
+      copy.push({
+        role: 'DEBUGGER',
+        phase: 'RECOVERY_LOOP',
+        used_as: 'system_prompt',
+        skill_source: 'defaults',
+        timestamp: new Date().toISOString(),
+      });
+
+      expect(registry.getEvents()).toHaveLength(1);
+    });
+  });
+
+  describe('getEventsForRole', () => {
+    it('should filter events by role', () => {
+      registry.record('ARCHITECT', 'ARCHITECTURE', 'system_prompt', 'defaults');
+      registry.record('REVIEWER', 'REVIEW', 'review_prompt', 'defaults');
+      registry.record('ARCHITECT', 'CONSENSUS_ARCHITECTURE', 'other', 'defaults');
+
+      const architectEvents = registry.getEventsForRole('ARCHITECT');
+      expect(architectEvents).toHaveLength(2);
+      expect(architectEvents.every((e) => e.role === 'ARCHITECT')).toBe(true);
+    });
+
+    it('should return empty array for role with no events', () => {
+      registry.record('ARCHITECT', 'ARCHITECTURE', 'system_prompt', 'defaults');
+
+      const debuggerEvents = registry.getEventsForRole('DEBUGGER');
+      expect(debuggerEvents).toHaveLength(0);
+    });
+  });
+
+  describe('hasUsage', () => {
+    it('should return true for role with recorded events', () => {
+      registry.record('AUDITOR', 'AUDIT', 'system_prompt', 'defaults');
+
+      expect(registry.hasUsage('AUDITOR')).toBe(true);
+    });
+
+    it('should return false for role with no events', () => {
+      expect(registry.hasUsage('DEBUGGER')).toBe(false);
+    });
+  });
+
+  describe('state serialization', () => {
+    it('should round-trip through JSON correctly', () => {
+      registry.record('ARCHITECT', 'ARCHITECTURE', 'system_prompt', 'defaults', '1.0');
+      registry.record('REVIEWER', 'REVIEW', 'review_prompt', 'project_override', '2.0');
+
+      // Simulate state serialization
+      const serialized = JSON.stringify(events);
+      const deserialized = JSON.parse(serialized) as SkillUsageEvent[];
+
+      // Create new registry from deserialized data
+      const newRegistry = new SkillUsageRegistry(deserialized);
+      expect(newRegistry.getEvents()).toHaveLength(2);
+      expect(newRegistry.hasUsage('ARCHITECT')).toBe(true);
+      expect(newRegistry.hasUsage('REVIEWER')).toBe(true);
+    });
+  });
+});

package/tests/pipeline/strategy-context.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Strategy context loader tests — loadStrategyForRole, STRATEGY_ROLES.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { STRATEGY_ROLES, loadStrategyForRole } from '../../src/pipeline/strategy-context.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-strategy-context-test');
+
+function makeValidStrategy() {
+  return {
+    icp: { primaryPersona: 'developers', painPoints: ['slow builds'], goals: ['fast CI'], objections: ['cost'] },
+    positioning: { category: 'DevTools', differentiators: ['speed'], valueProposition: 'Build faster', proofPoints: ['10x'] },
+    messaging: { headline: 'Build Faster', subheadline: 'CI that works', elevatorPitch: 'Fast CI', longDescription: 'A fast CI platform' },
+    seoStrategy: { primaryKeywords: ['CI'], secondaryKeywords: ['build'], longTailKeywords: ['fast CI'], titleTemplates: {}, metaDescriptions: {} },
+    siteArchitecture: {
+      pages: [{ path: '/', title: 'Home', purpose: 'Landing', pageType: 'landing', sections: ['hero'], seoKeywords: ['CI'], conversionGoal: 'signup' }],
+      navigation: [{ label: 'Home', href: '/' }],
+      footerSections: [{ title: 'Links', links: [{ label: 'Home', href: '/' }] }],
+    },
+    conversionStrategy: {
+      primaryCta: { text: 'Get Started', href: '/signup' },
+      secondaryCta: { text: 'Learn More', href: '/docs' },
+      trustSignals: ['SOC2'],
+      socialProof: ['1000+ teams'],
+      leadCapture: 'webhook',
+    },
+    competitiveContext: { category: 'CI/CD', competitors: ['CircleCI'], differentiators: ['speed'] },
+  };
+}
+
+beforeEach(() => {
+  mkdirSync(join(TEST_DIR, '.popeye'), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('STRATEGY_ROLES', () => {
+  it('includes exactly WEBSITE_PROGRAMMER, MARKETING_EXPERT, SOCIAL_EXPERT', () => {
+    expect(STRATEGY_ROLES).toContain('WEBSITE_PROGRAMMER');
+    expect(STRATEGY_ROLES).toContain('MARKETING_EXPERT');
+    expect(STRATEGY_ROLES).toContain('SOCIAL_EXPERT');
+    expect(STRATEGY_ROLES).toHaveLength(3);
+  });
+});
+
+describe('loadStrategyForRole', () => {
+  it('returns undefined when no strategy file exists', () => {
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBeUndefined();
+  });
+
+  it('returns formatted string when valid .popeye/website-strategy.json exists', () => {
+    const strategy = makeValidStrategy();
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify(strategy),
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBeDefined();
+    expect(result).toContain('Target Customer');
+    expect(result).toContain('developers');
+    expect(result).toContain('Build Faster');
+    expect(result).toContain('SEO Keywords');
+    expect(result).toContain('Conversion Strategy');
+  });
+
+  it('handles nested strategy field in JSON', () => {
+    const strategy = makeValidStrategy();
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify({ strategy, metadata: { inputHash: 'abc', generatedAt: '2025-01-01', version: 1 } }),
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBeDefined();
+    expect(result).toContain('developers');
+  });
+
+  it('returns undefined for malformed JSON', () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      '{ invalid json!!!',
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBeUndefined();
+  });
+
+  it('returns undefined for JSON that fails schema validation', () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify({ icp: { primaryPersona: '' } }),
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBeUndefined();
+  });
+
+  it('falls back to .popeye/website-strategy.md when JSON absent', () => {
+    const mdContent = '# Strategy\n\nTarget: developers\nKeywords: CI, build';
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.md'),
+      mdContent,
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBe(mdContent);
+  });
+
+  it('prefers JSON over MD when both exist', () => {
+    const strategy = makeValidStrategy();
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      JSON.stringify(strategy),
+    );
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.md'),
+      '# Fallback MD',
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    // JSON is checked first, should get formatted strategy not raw MD
+    expect(result).toContain('Target Customer');
+    expect(result).not.toContain('Fallback MD');
+  });
+
+  it('falls back to MD when JSON is malformed', () => {
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.json'),
+      '{ bad json }',
+    );
+    writeFileSync(
+      join(TEST_DIR, '.popeye', 'website-strategy.md'),
+      '# Good MD Strategy',
+    );
+
+    const result = loadStrategyForRole(TEST_DIR);
+    expect(result).toBe('# Good MD Strategy');
+  });
+});

package/tests/shared/text-utils.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Tests for isNoneVariant() and normalizeIssueList()
+ * Ensures false-positive blocking issues are filtered while real issues are preserved.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { isNoneVariant, normalizeIssueList } from '../../src/shared/text-utils.js';
+
+describe('isNoneVariant', () => {
+  describe('true positives (should be filtered out)', () => {
+    it('should detect exact "none" variants', () => {
+      expect(isNoneVariant('None')).toBe(true);
+      expect(isNoneVariant('none')).toBe(true);
+      expect(isNoneVariant('NONE')).toBe(true);
+      expect(isNoneVariant('None.')).toBe(true);
+      expect(isNoneVariant('N/A')).toBe(true);
+      expect(isNoneVariant('n/a')).toBe(true);
+      expect(isNoneVariant('NA')).toBe(true);
+      expect(isNoneVariant('Nil')).toBe(true);
+      expect(isNoneVariant('Nothing')).toBe(true);
+    });
+
+    it('should detect bullet-prefixed none-variants', () => {
+      expect(isNoneVariant('- None')).toBe(true);
+      expect(isNoneVariant('* N/A')).toBe(true);
+      expect(isNoneVariant('+ Nothing')).toBe(true);
+      expect(isNoneVariant('1) Nothing')).toBe(true);
+      expect(isNoneVariant('1. None')).toBe(true);
+    });
+
+    it('should detect "no issues" phrases', () => {
+      expect(isNoneVariant('No blocking issues')).toBe(true);
+      expect(isNoneVariant('No blocking issues found')).toBe(true);
+      expect(isNoneVariant('No issues')).toBe(true);
+      expect(isNoneVariant('No issues found')).toBe(true);
+      expect(isNoneVariant('No critical issues')).toBe(true);
+      expect(isNoneVariant('No blockers')).toBe(true);
+      expect(isNoneVariant('No showstoppers')).toBe(true);
+      expect(isNoneVariant('No concerns')).toBe(true);
+      expect(isNoneVariant('No significant issues')).toBe(true);
+      expect(isNoneVariant('No major blocking issues')).toBe(true);
+    });
+
+    it('should detect "none identified/found" phrases', () => {
+      expect(isNoneVariant('None identified')).toBe(true);
+      expect(isNoneVariant('None found')).toBe(true);
+      expect(isNoneVariant('None detected')).toBe(true);
+      expect(isNoneVariant('None at this time')).toBe(true);
+      expect(isNoneVariant('None noted')).toBe(true);
+      expect(isNoneVariant('None observed')).toBe(true);
+      expect(isNoneVariant('None reported')).toBe(true);
+      expect(isNoneVariant('None applicable')).toBe(true);
+    });
+
+    it('should detect "there are no" phrases', () => {
+      expect(isNoneVariant('There are no blocking issues')).toBe(true);
+      expect(isNoneVariant('There are no significant issues')).toBe(true);
+      expect(isNoneVariant('There are no major blocking issues')).toBe(true);
+      expect(isNoneVariant('There are no critical blockers')).toBe(true);
+    });
+
+    it('should handle empty and whitespace strings', () => {
+      expect(isNoneVariant('')).toBe(true);
+      expect(isNoneVariant('   ')).toBe(true);
+      expect(isNoneVariant('\n')).toBe(true);
+      expect(isNoneVariant('\t')).toBe(true);
+    });
+
+    it('should strip trailing punctuation before matching', () => {
+      expect(isNoneVariant('None.')).toBe(true);
+      expect(isNoneVariant('N/A.')).toBe(true);
+      expect(isNoneVariant('No issues!')).toBe(true);
+      expect(isNoneVariant('No blocking issues found.')).toBe(true);
+    });
+  });
+
+  describe('true negatives (must keep as real issues)', () => {
+    it('should keep real blocking issues', () => {
+      expect(isNoneVariant('Missing authentication layer')).toBe(false);
+      expect(isNoneVariant('SQL injection vulnerability')).toBe(false);
+      expect(isNoneVariant('The API has no rate limiting')).toBe(false);
+      expect(isNoneVariant('Authentication is not implemented')).toBe(false);
+    });
+
+    it('should keep "No rollback plan" (not issues/concerns/problems/blockers)', () => {
+      expect(isNoneVariant('No rollback plan defined')).toBe(false);
+    });
+
+    it('should keep "None of the..." sentences (classic false positive)', () => {
+      expect(isNoneVariant('None of the database migrations handle rollback')).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should reject long plain text (>80 chars) as real issues', () => {
+      const longIssue = 'The authentication system does not properly validate JWT tokens which could lead to unauthorized access to protected endpoints';
+      expect(longIssue.length).toBeGreaterThan(80);
+      expect(isNoneVariant(longIssue)).toBe(false);
+    });
+
+    it('should still detect long none-variant phrases', () => {
+      // A "no issues" phrase that happens to be long due to qualifiers
+      expect(isNoneVariant('No significant blocking issues or critical concerns identified in this review.')).toBe(true);
+    });
+  });
+});
+
+describe('normalizeIssueList', () => {
+  it('should filter out all none-variants from a list', () => {
+    const input = [
+      'None',
+      'No blocking issues found',
+      'Missing authentication layer',
+      'N/A',
+      'SQL injection vulnerability',
+    ];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual([
+      'Missing authentication layer',
+      'SQL injection vulnerability',
+    ]);
+  });
+
+  it('should handle empty lists', () => {
+    expect(normalizeIssueList([])).toEqual([]);
+  });
+
+  it('should filter out empty and whitespace-only items', () => {
+    const input = ['', '  ', 'Real issue', '\t'];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual(['Real issue']);
+  });
+
+  it('should trim items before checking', () => {
+    const input = ['  None  ', '  Missing auth  '];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual(['Missing auth']);
+  });
+
+  it('should preserve order of real issues', () => {
+    const input = [
+      'None',
+      'First real issue',
+      'N/A',
+      'Second real issue',
+      'Third real issue',
+    ];
+    const result = normalizeIssueList(input);
+    expect(result).toEqual([
+      'First real issue',
+      'Second real issue',
+      'Third real issue',
+    ]);
+  });
+});