popeye-cli 2.1.0 → 2.7.0

package/tests/adapters/gemini.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Tests for Gemini adapter - parseConsensusResponse
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseConsensusResponse } from '../../src/adapters/gemini.js';
+
+describe('Gemini parseConsensusResponse', () => {
+  it('should parse a complete response with blocking issues', () => {
+    const response = `
+ANALYSIS:
+Well-structured plan with clear goals.
+
+STRENGTHS:
+- Good module separation
+- Clear API design
+
+CONCERNS:
+- Consider adding rate limiting
+
+BLOCKING_ISSUES:
+- Missing authentication middleware
+- No input validation strategy
+
+RECOMMENDATIONS:
+- Add rate limiting middleware
+
+CONSENSUS: 72%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(72);
+    expect(result.approved).toBe(false);
+    expect(result.concerns).toEqual(['Consider adding rate limiting']);
+    expect(result.blockingIssues).toEqual([
+      'Missing authentication middleware',
+      'No input validation strategy',
+    ]);
+    expect(result.recommendations).toEqual(['Add rate limiting middleware']);
+  });
+
+  it('should return empty blocking issues when "None"', () => {
+    const response = `
+ANALYSIS:
+Excellent plan.
+
+STRENGTHS:
+- Comprehensive coverage
+
+CONCERNS:
+- Minor naming inconsistencies
+
+BLOCKING_ISSUES:
+- None
+
+RECOMMENDATIONS:
+- Standardize naming conventions
+
+CONSENSUS: 96%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(96);
+    expect(result.approved).toBe(true);
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.concerns).toHaveLength(1);
+  });
+
+  it('should handle missing BLOCKING_ISSUES section (backward compat)', () => {
+    const response = `
+ANALYSIS:
+Good plan overall.
+
+STRENGTHS:
+- Solid architecture design
+
+CONCERNS:
+- Some performance issue to watch
+
+RECOMMENDATIONS:
+- Optimize database queries
+
+CONSENSUS: 88%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.score).toBe(88);
+  });
+
+  it('should filter none-variant blocking issues like "No blocking issues found"', () => {
+    const response = `
+ANALYSIS:
+Good plan with solid foundation.
+
+STRENGTHS:
+- Clean design
+
+CONCERNS:
+- Minor performance concern
+
+BLOCKING_ISSUES:
+- No blocking issues found
+
+RECOMMENDATIONS:
+- Optimize queries
+
+CONSENSUS: 91%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter "None identified" from blocking issues', () => {
+    const response = `
+ANALYSIS:
+Thorough review complete.
+
+STRENGTHS:
+- Well-structured code
+
+CONCERNS:
+- Could use more tests
+
+BLOCKING_ISSUES:
+- None identified
+
+RECOMMENDATIONS:
+- Add integration tests
+
+CONSENSUS: 89%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should handle ALL-CAPS format for blocking issues', () => {
+    const response = `
+ANALYSIS:
+Detailed review of the plan.
+
+STRENGTHS:
+- Good structure
+
+CONCERNS:
+- Minor issue noted
+
+BLOCKING_ISSUES:
+- Critical security flaw
+
+RECOMMENDATIONS:
+- Fix security
+
+CONSENSUS: 60%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.blockingIssues).toEqual(['Critical security flaw']);
+    expect(result.recommendations).toEqual(['Fix security']);
+  });
+});

package/tests/adapters/grok.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for Grok adapter - parseConsensusResponse
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseConsensusResponse } from '../../src/adapters/grok.js';
+
+describe('Grok parseConsensusResponse', () => {
+  it('should parse a complete response with blocking issues', () => {
+    const response = `
+ANALYSIS:
+Solid plan with room for improvement.
+
+STRENGTHS:
+- Clean API design
+- Good test coverage plan
+
+CONCERNS:
+- Consider adding monitoring
+
+BLOCKING_ISSUES:
+- Missing database migration strategy
+- No rollback plan defined
+
+RECOMMENDATIONS:
+- Add observability layer
+
+CONSENSUS: 70%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(70);
+    expect(result.approved).toBe(false);
+    expect(result.concerns).toEqual(['Consider adding monitoring']);
+    expect(result.blockingIssues).toEqual([
+      'Missing database migration strategy',
+      'No rollback plan defined',
+    ]);
+  });
+
+  it('should return empty blocking issues when "None"', () => {
+    const response = `
+ANALYSIS:
+Great plan.
+
+STRENGTHS:
+- Well-structured
+
+CONCERNS:
+- Minor style inconsistencies
+
+BLOCKING_ISSUES:
+- None
+
+RECOMMENDATIONS:
+- Apply consistent formatting
+
+CONSENSUS: 95%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(95);
+    expect(result.approved).toBe(true);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter none-variant blocking issues like "No blocking issues found"', () => {
+    const response = `
+ANALYSIS:
+Solid implementation plan.
+
+STRENGTHS:
+- Good architecture
+
+CONCERNS:
+- Consider monitoring
+
+BLOCKING_ISSUES:
+- No blocking issues found
+
+RECOMMENDATIONS:
+- Add monitoring
+
+CONSENSUS: 93%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter "None identified" from blocking issues', () => {
+    const response = `
+ANALYSIS:
+Well-considered approach.
+
+STRENGTHS:
+- Comprehensive coverage
+
+CONCERNS:
+- Minor style issues
+
+BLOCKING_ISSUES:
+- None identified
+
+RECOMMENDATIONS:
+- Standardize formatting
+
+CONSENSUS: 91%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should handle missing BLOCKING_ISSUES section (backward compat)', () => {
+    const response = `
+ANALYSIS:
+Reasonable plan.
+
+STRENGTHS:
+- Good overall approach
+
+CONCERNS:
+- Needs more detail
+
+RECOMMENDATIONS:
+- Expand on implementation details
+
+CONSENSUS: 82%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.score).toBe(82);
+  });
+});

package/tests/adapters/openai.test.ts

@@ -22,6 +22,9 @@ CONCERNS:
 - No deployment plan
 - Security considerations not addressed
 
+BLOCKING_ISSUES:
+- None
+
 RECOMMENDATIONS:
 - Add error handling middleware
 - Include deployment configuration
@@ -37,6 +40,7 @@ CONSENSUS: 85%
     expect(result.analysis).toContain('well-structured plan');
     expect(result.strengths).toContain('Clear project structure');
     expect(result.concerns).toContain('Missing error handling strategy');
+    expect(result.blockingIssues).toEqual([]);
     expect(result.recommendations).toContain('Add error handling middleware');
     expect(result.rawResponse).toBe(response);
   });
@@ -52,6 +56,9 @@ STRENGTHS:
 CONCERNS:
 - None
 
+BLOCKING_ISSUES:
+- None
+
 RECOMMENDATIONS:
 - None needed
 
@@ -62,6 +69,7 @@ CONSENSUS: 98%
 
     expect(result.score).toBe(98);
     expect(result.approved).toBe(true);
+    expect(result.blockingIssues).toEqual([]);
   });
 
   it('should handle missing sections gracefully', () => {
@@ -78,6 +86,7 @@ CONSENSUS: 70%
     expect(result.analysis).toBe('');
     expect(result.strengths).toEqual([]);
     expect(result.concerns).toEqual([]);
+    expect(result.blockingIssues).toEqual([]);
   });
 
   it('should handle missing score', () => {
@@ -110,6 +119,9 @@ CONCERNS:
 1. First concern
 2. Second concern
 
+BLOCKING_ISSUES:
+- None
+
 RECOMMENDATIONS:
 - Recommendation one
 - Recommendation two
@@ -121,6 +133,7 @@ CONSENSUS: 80%
 
     expect(result.strengths).toHaveLength(4);
     expect(result.concerns).toHaveLength(2);
+    expect(result.blockingIssues).toEqual([]);
     expect(result.recommendations).toHaveLength(2);
   });
 
@@ -142,4 +155,119 @@ CONSENSUS: 80%
     expect(parseConsensusResponse('CONSENSUS: 0%').score).toBe(0);
     expect(parseConsensusResponse('CONSENSUS: 100%').score).toBe(100);
   });
+
+  it('should parse blocking issues as separate field', () => {
+    const response = `
+ANALYSIS: Good plan.
+
+STRENGTHS:
+- Solid architecture
+
+CONCERNS:
+- Consider adding caching
+
+BLOCKING_ISSUES:
+- Missing authentication flow
+- No database migration strategy
+
+RECOMMENDATIONS:
+- Add caching layer
+
+CONSENSUS: 72%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([
+      'Missing authentication flow',
+      'No database migration strategy',
+    ]);
+    expect(result.concerns).toEqual(['Consider adding caching']);
+  });
+
+  it('should return empty blocking issues when "None"', () => {
+    const response = `
+ANALYSIS: Good plan.
+
+STRENGTHS:
+- Solid
+
+CONCERNS:
+- Minor naming issues in the module structure
+
+BLOCKING_ISSUES:
+- None
+
+RECOMMENDATIONS:
+- Improve module names
+
+CONSENSUS: 95%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.approved).toBe(true);
+  });
+
+  it('should filter none-variant blocking issues like "No blocking issues found"', () => {
+    const response = `
+ANALYSIS: Good plan.
+
+STRENGTHS:
+- Solid architecture
+
+CONCERNS:
+- Minor naming issues
+
+BLOCKING_ISSUES:
+- No blocking issues found
+
+RECOMMENDATIONS:
+- Improve naming
+
+CONSENSUS: 92%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter "None identified" from blocking issues', () => {
+    const response = `
+ANALYSIS: Solid plan overall.
+
+STRENGTHS:
+- Good design choices
+
+CONCERNS:
+- Consider caching
+
+BLOCKING_ISSUES:
+- None identified
+
+RECOMMENDATIONS:
+- Add caching layer
+
+CONSENSUS: 90%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should handle missing BLOCKING_ISSUES section (backward compat)', () => {
+    // Old-format response without BLOCKING_ISSUES section
+    const response = `
+ANALYSIS: Good plan.
+
+STRENGTHS:
+- Fine overall structure
+
+CONCERNS:
+- Some concern about performance
+
+RECOMMENDATIONS:
+- A recommendation for optimization
+
+CONSENSUS: 90%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.concerns).toHaveLength(1);
+  });
 });

package/tests/generators/doc-parser.test.ts

@@ -104,18 +104,97 @@ describe('isSuspiciousProductName', () => {
 });
 
 describe('extractPricing', () => {
-  it('extracts pricing tiers from markdown table', () => {
+  it('extracts pricing tiers from markdown table with provenance', () => {
     const docs = `## Pricing\n| Plan | Price |\n|---|---|\n| Free | Free |\n| Pro | $99/month minimum |\n| Enterprise | Custom pricing |`;
-    const tiers = extractPricing(docs);
-    expect(tiers).toBeDefined();
-    expect(tiers!.length).toBe(3);
-    expect(tiers![0].name).toContain('Free');
-    expect(tiers![1].price).toBe('$99');
-    expect(tiers![2].price).toBe('Custom');
+    const result = extractPricing(docs);
+    expect(result.source).toBe('docs');
+    expect(result.tiers.length).toBe(3);
+    expect(result.tiers[0].name).toContain('Free');
+    expect(result.tiers[1].price).toBe('$99');
+    expect(result.tiers[2].price).toBe('Custom');
+    expect(result.evidence).toBeDefined();
+    expect(result.evidence!.extractionMethod).toBe('known_plan_names');
+    expect(result.evidence!.matchedRows).toBe(3);
   });
 
-  it('returns undefined when no pricing found', () => {
+  it('returns source none when no pricing found', () => {
     const docs = '# Product\nJust a product.';
-    expect(extractPricing(docs)).toBeUndefined();
+    const result = extractPricing(docs);
+    expect(result.source).toBe('none');
+    expect(result.tiers).toEqual([]);
+    expect(result.evidence).toBeUndefined();
+  });
+
+  it('extracts Gateco-style pricing with emoji-prefixed rows and <br> tags', () => {
+    const docs = [
+      '## Pricing Overview',
+      '| Plan | Price | Users |',
+      '|---|---|---|',
+      '| Free | Free | Up to 5 |',
+      '| Pro | $99/month<br>minimum | Unlimited |',
+      '| Enterprise | Custom | Unlimited |',
+    ].join('\n');
+    const result = extractPricing(docs);
+    expect(result.source).toBe('docs');
+    expect(result.tiers.length).toBe(3);
+    expect(result.tiers[0].name).toBe('Free');
+    expect(result.tiers[0].price).toBe('Free');
+    expect(result.tiers[1].name).toBe('Pro');
+    expect(result.tiers[1].price).toBe('$99');
+    expect(result.tiers[2].name).toBe('Enterprise');
+    expect(result.tiers[2].price).toBe('Custom');
+  });
+
+  it('falls back to table_fallback for nonstandard plan names', () => {
+    const docs = [
+      '## Pricing',
+      '| Plan | Price |',
+      '|---|---|',
+      '| Hobby | Free |',
+      '| Scale | $49/mo |',
+      '| Organization | Custom |',
+    ].join('\n');
+    const result = extractPricing(docs);
+    expect(result.source).toBe('docs');
+    expect(result.tiers.length).toBe(3);
+    expect(result.evidence!.extractionMethod).toBe('table_fallback');
+    expect(result.tiers[0].name).toBe('Hobby');
+    expect(result.tiers[1].name).toBe('Scale');
+    expect(result.tiers[2].name).toBe('Organization');
+  });
+
+  it('detects price in 3rd column via header scan', () => {
+    const docs = [
+      '## Pricing',
+      '| Plan | Features | Price |',
+      '|---|---|---|',
+      '| Hobby | 5 projects | Free |',
+      '| Scale | Unlimited | $49/mo |',
+    ].join('\n');
+    const result = extractPricing(docs);
+    expect(result.source).toBe('docs');
+    expect(result.tiers.length).toBe(2);
+    expect(result.tiers[0].price).toBe('Free');
+    expect(result.tiers[1].price).toBe('$49');
+  });
+
+  it('skips separator rows and header-like rows in fallback', () => {
+    const docs = [
+      '## Pricing',
+      '| Plan | Price |',
+      '|---|---|',
+      '| Plan | $10 |',  // header-like row, should skip
+      '| Hobby | Free |',
+    ].join('\n');
+    const result = extractPricing(docs);
+    // "Plan" row should be skipped by the /^(Plan|Tier|Name|Feature)/i filter
+    expect(result.tiers.every((t) => t.name !== 'Plan')).toBe(true);
+  });
+
+  it('returns empty tiers for pricing section with no table', () => {
+    const docs = '## Pricing\nContact us for pricing details.';
+    const result = extractPricing(docs);
+    expect(result.source).toBe('none');
+    expect(result.tiers).toEqual([]);
   });
 });

package/tests/generators/quality-gate.test.ts

@@ -75,7 +75,7 @@ describe('validateWebsiteContextOrThrow', () => {
   });
 
   it('still throws when passed is false from validateWebsiteContext', () => {
-    // Context with multiple blocking issues
+    // Context with multiple blocking issues (strategy absence is not a factor)
     const context = makeContext({
       productName: 'my-app',
       rawDocs: '',
@@ -87,6 +87,13 @@ describe('validateWebsiteContextOrThrow', () => {
       /Website generation blocked/
     );
   });
+
+  it('does not throw on missing strategy alone', () => {
+    // Strategy absence should never cause validation failure
+    const context = makeContext({ strategy: undefined });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'gateco')).not.toThrow();
+  });
 });
 
 describe('validateWebsiteContext (soft mode)', () => {
@@ -168,7 +175,7 @@ describe('validateWebsiteContext (soft mode)', () => {
     expect(result.warnings.some((w) => /description/i.test(w))).toBe(true);
   });
 
-  it('clamps score to 0 when everything is wrong', () => {
+  it('clamps score to floor when everything is wrong', () => {
     const context: WebsiteContentContext = {
       productName: 'my-app',
       features: [],
@@ -177,7 +184,16 @@ describe('validateWebsiteContext (soft mode)', () => {
     };
     const result = validateWebsiteContext(context, 'my-app');
 
-    expect(result.contentScore).toBe(0);
+    // Score is low but no longer 0 since strategy penalty (-15) was removed
+    expect(result.contentScore).toBeLessThanOrEqual(15);
     expect(result.passed).toBe(false);
   });
+
+  it('does not emit strategy-related issues when strategy is undefined', () => {
+    const context = makeContext({ strategy: undefined });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    // Strategy absence should not produce any issues or warnings about strategy
+    expect(result.issues.some((i) => /strategy/i.test(i))).toBe(false);
+  });
 });

package/tests/generators/website-components.test.ts

@@ -9,6 +9,7 @@ import {
   generateWebsiteFooter,
   generateWebsiteNavigation,
 } from '../../src/generators/templates/website-components.js';
+import { getWebsiteProjectFiles } from '../../src/generators/website.js';
 import type { WebsiteContentContext } from '../../src/generators/website-context.js';
 import type { WebsiteStrategyDocument } from '../../src/types/website-strategy.js';
 
@@ -132,6 +133,39 @@ describe('generateWebsiteFooter', () => {
     expect(footer).toContain('Resources');
     expect(footer).toContain('Legal');
   });
+
+  it('all default footer hrefs have corresponding generated pages', () => {
+    const footer = generateWebsiteFooter('deploy-ai', contextNoLogo);
+    const generatedFiles = getWebsiteProjectFiles('deploy-ai');
+
+    // Extract all href values from the default footer
+    const hrefPattern = /href:\s*'([^']+)'/g;
+    let match;
+    const hrefs: string[] = [];
+    while ((match = hrefPattern.exec(footer)) !== null) {
+      hrefs.push(match[1]);
+    }
+
+    // Build set of generated page routes from file paths
+    const pageRoutes = new Set<string>();
+    for (const file of generatedFiles) {
+      const pageMatch = file.match(/^src\/app(.*)\/page\.tsx$/);
+      if (pageMatch) {
+        pageRoutes.add(pageMatch[1] || '/');
+      }
+    }
+    // Also add root route
+    if (generatedFiles.includes('src/app/page.tsx')) {
+      pageRoutes.add('/');
+    }
+
+    // Every non-anchor internal href should correspond to a generated page
+    for (const href of hrefs) {
+      if (href.startsWith('/#')) continue; // Anchor links are fine
+      if (!href.startsWith('/')) continue; // External links are fine
+      expect(pageRoutes.has(href)).toBe(true);
+    }
+  });
 });
 
 describe('generateWebsiteNavigation', () => {