popeye-cli 2.2.0 → 2.7.0

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', () => {

package/tests/generators/website-content-ai.test.ts

@@ -0,0 +1,308 @@
+/**
+ * AI Website Content Generator tests — pricing guard, evidence detection,
+ * doc path extraction, and per-field AI fallback.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { hasPricingEvidence } from '../../src/generators/website-content-ai.js';
+import {
+  extractDocPathsFromText,
+  validateAndFilterDocPaths,
+  validateWebsiteContext,
+} from '../../src/generators/website-context.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+
+describe('website-content-ai', () => {
+  describe('hasPricingEvidence', () => {
+    it('should detect dollar amounts in docs', () => {
+      expect(hasPricingEvidence('Plans start at $29/mo', '')).toBe(true);
+    });
+
+    it('should detect euro amounts', () => {
+      expect(hasPricingEvidence('Starting from €19/month', '')).toBe(true);
+    });
+
+    it('should detect pricing keywords', () => {
+      expect(hasPricingEvidence('Our pricing model includes three tiers', '')).toBe(true);
+    });
+
+    it('should detect subscription keywords', () => {
+      expect(hasPricingEvidence('Monthly subscription available', '')).toBe(true);
+    });
+
+    it('should detect free plan/tier', () => {
+      expect(hasPricingEvidence('We offer a free tier for developers', '')).toBe(true);
+    });
+
+    it('should detect evidence in specification', () => {
+      expect(hasPricingEvidence('', 'Pricing plan: $49/mo')).toBe(true);
+    });
+
+    it('should return false for docs without pricing info', () => {
+      expect(hasPricingEvidence(
+        'Our product helps you build amazing software with AI.',
+        'A task management tool for teams.',
+      )).toBe(false);
+    });
+
+    it('should return false for empty inputs', () => {
+      expect(hasPricingEvidence('', '')).toBe(false);
+    });
+  });
+
+  describe('pricing guard edge cases', () => {
+    it('should detect /yr pattern', () => {
+      expect(hasPricingEvidence('$299/yr for annual plans', '')).toBe(true);
+    });
+
+    it('should detect per month even without dollar sign', () => {
+      // Reason: "per month" is a strong pricing signal regardless of currency symbol
+      expect(hasPricingEvidence('10 per month for basic plan', '')).toBe(true);
+      expect(hasPricingEvidence('$10 per month for basic plan', '')).toBe(true);
+    });
+
+    it('should detect USD pattern', () => {
+      expect(hasPricingEvidence('USD 29 per month', '')).toBe(true);
+    });
+  });
+
+  describe('extractDocPathsFromText', () => {
+    it('should extract macOS paths with spaces (quoted)', () => {
+      const text = `Build a website for Gateco using '/Users/a b/Gateco/pricing.md'`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('/Users/a b/Gateco/pricing.md');
+    });
+
+    it('should extract macOS paths without quotes', () => {
+      const text = 'Build a website using /Users/me/Gateco/spec.md please';
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('/Users/me/Gateco/spec.md');
+    });
+
+    it('should extract Windows paths with backslashes (quoted)', () => {
+      const text = `Use "C:\\Users\\me\\Gateco\\pricing.md" for content`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('C:\\Users\\me\\Gateco\\pricing.md');
+    });
+
+    it('should extract Windows paths with forward slashes', () => {
+      const text = `Docs at 'D:/docs/spec.md'`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('D:/docs/spec.md');
+    });
+
+    it('should extract multiple paths from mixed text', () => {
+      const text = `Build with '/Users/me/spec.md' and "/Users/me/pricing.md"`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('/Users/me/spec.md');
+      expect(paths).toContain('/Users/me/pricing.md');
+      expect(paths).toHaveLength(2);
+    });
+
+    it('should deduplicate paths', () => {
+      const text = `Use '/Users/me/spec.md' and '/Users/me/spec.md' twice`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toHaveLength(1);
+    });
+
+    it('should accept .mdx and .txt extensions', () => {
+      const text = `Read '/docs/spec.mdx' and '/docs/notes.txt'`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('/docs/spec.mdx');
+      expect(paths).toContain('/docs/notes.txt');
+    });
+
+    it('should reject .pdf and .docx extensions', () => {
+      const text = `Read '/docs/spec.pdf' and '/docs/notes.docx'`;
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toHaveLength(0);
+    });
+
+    it('should return empty for text without paths', () => {
+      const text = 'Build a website for my project';
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toHaveLength(0);
+    });
+
+    it('should handle paths at end of string', () => {
+      const text = 'Build from /Users/me/spec.md';
+      const paths = extractDocPathsFromText(text);
+      expect(paths).toContain('/Users/me/spec.md');
+    });
+  });
+
+  describe('validateAndFilterDocPaths', () => {
+    it('should reject unsupported extensions with log', async () => {
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const result = await validateAndFilterDocPaths(['/tmp/doc.pdf']);
+      expect(result).toHaveLength(0);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining('unsupported format'),
+      );
+      logSpy.mockRestore();
+    });
+
+    it('should skip non-existent files with log', async () => {
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const result = await validateAndFilterDocPaths(['/tmp/nonexistent-abc-123.md']);
+      expect(result).toHaveLength(0);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining('file not found'),
+      );
+      logSpy.mockRestore();
+    });
+
+    it('should accept allowed extensions for existing files', async () => {
+      // Reason: uses node:fs/promises, so we mock stat
+      const { promises: fsp } = await import('node:fs');
+      const statSpy = vi.spyOn(fsp, 'stat').mockResolvedValue({ size: 1024 } as any);
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      const result = await validateAndFilterDocPaths(['/tmp/test.md']);
+      expect(result).toEqual(['/tmp/test.md']);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[doc-ingest] Read:'),
+      );
+
+      statSpy.mockRestore();
+      logSpy.mockRestore();
+    });
+
+    it('should skip oversized files', async () => {
+      const { promises: fsp } = await import('node:fs');
+      const statSpy = vi.spyOn(fsp, 'stat').mockResolvedValue({
+        size: 3 * 1024 * 1024, // 3MB > 2MB limit
+      } as any);
+      const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      const result = await validateAndFilterDocPaths(['/tmp/huge.md']);
+      expect(result).toHaveLength(0);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining('exceeds 2MB limit'),
+      );
+
+      statSpy.mockRestore();
+      logSpy.mockRestore();
+    });
+  });
+
+  describe('per-field AI fallback', () => {
+    it('should treat pricing: [] as missing (empty array)', () => {
+      // Reason: the fix changes `!context.pricing` to `context.pricing == null || context.pricing.length === 0`
+      const emptyPricing: any[] = [];
+      const isMissing = emptyPricing == null || emptyPricing.length === 0;
+      expect(isMissing).toBe(true);
+    });
+
+    it('should treat pricing: undefined as missing', () => {
+      const undefinedPricing = undefined;
+      const isMissing = undefinedPricing == null || (undefinedPricing as any)?.length === 0;
+      expect(isMissing).toBe(true);
+    });
+
+    it('should not treat populated pricing as missing', () => {
+      const pricing = [{ name: 'Pro', price: '$29', description: '', features: [], cta: 'Buy' }];
+      const isMissing = pricing == null || pricing.length === 0;
+      expect(isMissing).toBe(false);
+    });
+
+    it('should trigger fallback when only pricing is missing', () => {
+      // Reason: verifies per-field logic — tagline exists but pricing is empty
+      const context = {
+        tagline: 'Existing tagline',
+        description: 'Existing description',
+        features: [{ title: 'A', description: 'B' }],
+        pricing: [] as any[],
+      };
+      const pricingMissing = context.pricing == null || context.pricing.length === 0;
+      const hasMissingContent = !context.tagline || !context.description || context.features.length === 0 || pricingMissing;
+      expect(hasMissingContent).toBe(true);
+      expect(pricingMissing).toBe(true);
+    });
+
+    it('should not trigger fallback when all fields are present', () => {
+      const context = {
+        tagline: 'Tag',
+        description: 'Desc',
+        features: [{ title: 'A', description: 'B' }],
+        pricing: [{ name: 'Free', price: '$0', description: '', features: [], cta: 'Start' }],
+      };
+      const pricingMissing = context.pricing == null || context.pricing.length === 0;
+      const hasMissingContent = !context.tagline || !context.description || context.features.length === 0 || pricingMissing;
+      expect(hasMissingContent).toBe(false);
+    });
+  });
+
+  describe('validator provenance-based pricing check', () => {
+    it('should NOT warn about default pricing when source is docs', () => {
+      const context: WebsiteContentContext = {
+        productName: 'Gateco',
+        features: [{ title: 'Auth', description: 'Auth feature' }],
+        rawDocs: '# Gateco\nSome docs content here for minimum length requirement...',
+        pricing: [
+          { name: 'Free', price: 'Free', description: '', features: [], cta: 'Get started' },
+          { name: 'Pro', price: '$99', description: '', features: [], cta: 'Start free trial' },
+          { name: 'Enterprise', price: 'Custom', description: '', features: [], cta: 'Contact sales' },
+        ],
+        pricingDiagnostics: {
+          charsScanned: 5000,
+          foundPricingHeader: true,
+          extractionMethod: 'known_plan_names',
+          extractedTiers: [
+            { name: 'Free', price: 'Free' },
+            { name: 'Pro', price: '$99' },
+            { name: 'Enterprise', price: 'Custom' },
+          ],
+          source: 'docs',
+        },
+      };
+      const result = validateWebsiteContext(context, 'Gateco');
+      const defaultWarning = result.warnings.find((w) => w.includes('default values'));
+      expect(defaultWarning).toBeUndefined();
+    });
+
+    it('should NOT warn about default pricing when source is ai', () => {
+      const context: WebsiteContentContext = {
+        productName: 'TestApp',
+        features: [{ title: 'Feature', description: 'Desc' }],
+        rawDocs: '# TestApp\nSome docs content here for minimum length...',
+        pricing: [
+          { name: 'Starter', price: '$0', description: '', features: [], cta: 'Get started' },
+          { name: 'Pro', price: '$29', description: '', features: [], cta: 'Start' },
+          { name: 'Enterprise', price: 'Custom', description: '', features: [], cta: 'Contact' },
+        ],
+        pricingDiagnostics: {
+          charsScanned: 3000,
+          foundPricingHeader: false,
+          extractionMethod: 'ai',
+          extractedTiers: [
+            { name: 'Starter', price: '$0' },
+            { name: 'Pro', price: '$29' },
+            { name: 'Enterprise', price: 'Custom' },
+          ],
+          source: 'ai',
+        },
+      };
+      const result = validateWebsiteContext(context, 'TestApp');
+      const defaultWarning = result.warnings.find((w) => w.includes('default values'));
+      expect(defaultWarning).toBeUndefined();
+    });
+
+    it('should warn about default pricing when no diagnostics present', () => {
+      const context: WebsiteContentContext = {
+        productName: 'TestApp',
+        features: [{ title: 'Feature', description: 'Desc' }],
+        rawDocs: '# TestApp\nSome docs content here for minimum length...',
+        pricing: [
+          { name: 'Starter', price: '$0', description: '', features: [], cta: 'Get started' },
+          { name: 'Pro', price: '$29', description: '', features: [], cta: 'Start' },
+          { name: 'Enterprise', price: 'Custom', description: '', features: [], cta: 'Contact' },
+        ],
+        // No pricingDiagnostics — simulates legacy or missing provenance
+      };
+      const result = validateWebsiteContext(context, 'TestApp');
+      const defaultWarning = result.warnings.find((w) => w.includes('default values'));
+      expect(defaultWarning).toBeDefined();
+    });
+  });
+});