popeye-cli 1.5.0 → 1.6.0

package/src/workflow/website-strategy.ts

@@ -70,7 +70,7 @@ Analyze the following product documentation and generate a complete website mark
 PRODUCT NAME: ${input.projectName}
 
 PRODUCT DOCUMENTATION:
-${input.productContext.slice(0, 8000)}
+${packProductContext(input.productContext)}
 ${competitorsBlock}${keywordsBlock}${marketNotesBlock}
 
 Generate a JSON response matching this exact structure:
@@ -290,6 +290,80 @@ export async function isStrategyStale(
   return stored.metadata.inputHash !== currentHash;
 }
 
+/**
+ * Pack product context into a budget with priority-based ordering
+ * Ensures high-priority docs (spec, pricing, brand) are included first
+ *
+ * @param productContext - Raw concatenated docs with "--- filename ---" headers
+ * @param budget - Maximum character budget (default 16000)
+ * @returns Packed context string within budget
+ */
+export function packProductContext(productContext: string, budget: number = 16000): string {
+  // Split by doc headers (--- filename ---)
+  const headerPattern = /^---\s+(.+?)\s+---$/gm;
+  const sections: Array<{ header: string; content: string; priority: number }> = [];
+  let lastIndex = 0;
+  let lastHeader = '';
+  let match;
+
+  while ((match = headerPattern.exec(productContext)) !== null) {
+    if (lastIndex > 0) {
+      sections.push({
+        header: lastHeader,
+        content: productContext.slice(lastIndex, match.index).trim(),
+        priority: getDocSortPriority(lastHeader),
+      });
+    }
+    lastHeader = match[0];
+    lastIndex = match.index + match[0].length;
+  }
+  // Push the last section
+  if (lastIndex > 0 && lastIndex < productContext.length) {
+    sections.push({
+      header: lastHeader,
+      content: productContext.slice(lastIndex).trim(),
+      priority: getDocSortPriority(lastHeader),
+    });
+  }
+
+  // If no headers found, return the raw context trimmed to budget
+  if (sections.length === 0) {
+    return productContext.slice(0, budget);
+  }
+
+  // Sort by priority (lower = more important)
+  sections.sort((a, b) => a.priority - b.priority);
+
+  // Pack into budget
+  let packed = '';
+  for (const section of sections) {
+    const block = `${section.header}\n${section.content}\n\n`;
+    if (packed.length + block.length <= budget) {
+      packed += block;
+    } else {
+      const remaining = budget - packed.length;
+      if (remaining > 200) {
+        packed += `${section.header}\n${section.content.slice(0, remaining - section.header.length - 10)}...\n`;
+      }
+      break;
+    }
+  }
+
+  return packed.trim();
+}
+
+/**
+ * Get sort priority for a doc section header (lower = higher priority)
+ */
+function getDocSortPriority(header: string): number {
+  const lower = header.toLowerCase();
+  if (/spec/i.test(lower)) return 1;
+  if (/pricing/i.test(lower)) return 2;
+  if (/color|brand/i.test(lower)) return 3;
+  if (/feature/i.test(lower)) return 4;
+  return 5;
+}
+
 /**
  * Compute SHA-256 hash of strategy inputs for staleness detection
  */

package/src/workflow/website-updater.ts

@@ -9,13 +9,14 @@ import path from 'node:path';
 import type { ProjectState } from '../types/workflow.js';
 import type { OutputLanguage } from '../types/project.js';
 import { isWorkspace } from '../types/project.js';
-import { buildWebsiteContext } from '../generators/website-context.js';
+import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext } from '../generators/website-context.js';
+import { resolveWorkspaceRoot } from '../generators/workspace-root.js';
+import { generateWebsiteLandingPage } from '../generators/templates/website-landing.js';
+import { generateWebsitePricingPage } from '../generators/templates/website-pricing.js';
 import {
-  generateWebsiteLandingPage,
-  generateWebsitePricingPage,
   generateWebsiteLayout,
   generateWebsiteGlobalsCss,
-} from '../generators/templates/website.js';
+} from '../generators/templates/website-layout.js';
 import {
   generateWebsiteHeader,
   generateWebsiteFooter,
@@ -71,6 +72,10 @@ export async function updateWebsiteContent(
     };
   }
 
+  // Resolve brand assets using workspace root for proper logo resolution
+  const workspaceRoot = await resolveWorkspaceRoot(parentDir);
+  context.brandAssets = await resolveBrandAssets(workspaceRoot, context.brand);
+
   // Load website strategy if available
   const strategyData = await loadWebsiteStrategy(projectDir);
   if (strategyData) {
@@ -78,6 +83,12 @@ export async function updateWebsiteContent(
     onProgress?.('Loaded website strategy for content update');
   }
 
+  // Soft validation: report quality issues via progress callback
+  const validation = validateWebsiteContext(context, state.name);
+  for (const msg of [...validation.issues, ...validation.warnings]) {
+    onProgress?.(`[quality-gate] ${msg}`);
+  }
+
   onProgress?.('Updating website content with project context...');
 
   // Re-generate content files
@@ -116,11 +127,11 @@ export async function updateWebsiteContent(
     }
   }
 
-  // Copy logo to public/ if brand context has one
+  // Copy logo to public/brand/ if brand context has one
   if (context.brand?.logoPath) {
     try {
       const logoExt = path.extname(context.brand.logoPath);
-      const destPath = path.join(websiteDir, 'public', `logo${logoExt}`);
+      const destPath = path.join(websiteDir, 'public', 'brand', `logo${logoExt}`);
       await fs.copyFile(context.brand.logoPath, destPath);
     } catch {
       // Non-blocking

package/tests/cli/project-naming.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for project naming logic
+ * Verifies CWD-aware naming, doc-derived names, and fallback behavior
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {
+  generateProjectName,
+  generateProjectNameFromIdea,
+  extractNameFromDocs,
+} from '../../src/cli/interactive.js';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-naming-'));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('generateProjectNameFromIdea', () => {
+  it('should extract explicit project name patterns', () => {
+    // "named" pattern extracts the word after it
+    expect(generateProjectNameFromIdea("Create an app named 'Gateco'")).toBe('gateco');
+    // "called" pattern extracts the word after it
+    expect(generateProjectNameFromIdea('Build something called TodoApp')).toBe('todo-app');
+  });
+
+  it('should extract CamelCase project names', () => {
+    // Without "for" keyword that triggers the explicit pattern, CamelCase is detected
+    expect(generateProjectNameFromIdea('Build TodoMaster with style')).toBe('todo-master');
+  });
+
+  it('should filter out action words from prompt text', () => {
+    // "read all files" should NOT produce "read-all-files" since those are stop words
+    const result = generateProjectNameFromIdea('read all files');
+    expect(result).not.toBe('read-all-files');
+    // Meaningful word extraction filters all three, but the fallback takes first 2 raw words
+    expect(result).toBe('read-all');
+  });
+
+  it('should extract meaningful words when no explicit name found', () => {
+    const result = generateProjectNameFromIdea('secure enterprise authentication system');
+    expect(result).toBe('secure-enterprise-authentication');
+  });
+
+  it('should return my-project as last resort', () => {
+    expect(generateProjectNameFromIdea('')).toBe('my-project');
+  });
+});
+
+describe('extractNameFromDocs', () => {
+  it('should extract product name from markdown heading', async () => {
+    const docPath = path.join(tmpDir, 'Gateco-spec.md');
+    await fs.writeFile(docPath, '# Gateco\n\nSome description here.');
+
+    const name = await extractNameFromDocs(tmpDir);
+    expect(name).toBe('Gateco');
+  });
+
+  it('should skip README files', async () => {
+    await fs.writeFile(path.join(tmpDir, 'README.md'), '# MyProject\n\nDescription.');
+
+    const name = await extractNameFromDocs(tmpDir);
+    expect(name).toBeNull();
+  });
+
+  it('should return null when no docs found', async () => {
+    const name = await extractNameFromDocs(tmpDir);
+    expect(name).toBeNull();
+  });
+
+  it('should return null for non-existent directory', async () => {
+    const name = await extractNameFromDocs('/nonexistent/path/123456');
+    expect(name).toBeNull();
+  });
+
+  it('should ignore generic headings', async () => {
+    // "Home" is too short, but length >= 3 so it would pass... let's test with a generic dir name
+    await fs.writeFile(path.join(tmpDir, 'spec.md'), '# Src\n\nDescription.');
+
+    const name = await extractNameFromDocs(tmpDir);
+    // "Src" is in GENERIC_DIR_NAMES
+    expect(name).toBeNull();
+  });
+});
+
+describe('generateProjectName (CWD-aware)', () => {
+  it('should prefer doc-derived name over CWD basename', async () => {
+    const projectDir = path.join(tmpDir, 'SomeDir');
+    await fs.mkdir(projectDir, { recursive: true });
+    await fs.writeFile(
+      path.join(projectDir, 'product-spec.md'),
+      '# Gateco\n\nA security layer for AI.'
+    );
+
+    const name = await generateProjectName('read all files', projectDir);
+    expect(name).toBe('gateco');
+  });
+
+  it('should use CWD basename when no docs found', async () => {
+    const projectDir = path.join(tmpDir, 'MyAwesomeApp');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const name = await generateProjectName('read all files', projectDir);
+    expect(name).toBe('my-awesome-app');
+  });
+
+  it('should skip generic CWD names and fall back to idea', async () => {
+    const projectDir = path.join(tmpDir, 'Projects');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    // "Projects" is a generic dir name, so falls back to idea extraction
+    // The idea contains "named SuperApp" pattern -> extracts "SuperApp"
+    const name = await generateProjectName('Build an app named SuperApp', projectDir);
+    expect(name).toBe('super-app');
+  });
+
+  it('should fall back to idea extraction when no CWD provided', async () => {
+    const name = await generateProjectName('Build an app called Gateco');
+    expect(name).toBe('gateco');
+  });
+
+  it('should handle CamelCase CWD basenames', async () => {
+    const projectDir = path.join(tmpDir, 'MyGateco');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const name = await generateProjectName('some idea', projectDir);
+    expect(name).toBe('my-gateco');
+  });
+});

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

@@ -0,0 +1,121 @@
+/**
+ * Tests for doc-parser module
+ * Verifies feature extraction, dev-task filtering, docs-first priority
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  extractFeatures,
+  extractProductName,
+  extractTagline,
+  extractDescription,
+  extractPrimaryColor,
+  extractPricing,
+  isSuspiciousProductName,
+} from '../../src/generators/doc-parser.js';
+
+describe('extractFeatures', () => {
+  it('extracts features from docs bullet list', () => {
+    const docs = `# Product\n## Features\n- **Fast Search** - Lightning fast search\n- **Auth** - Built-in authentication`;
+    const features = extractFeatures(docs);
+    expect(features.length).toBeGreaterThanOrEqual(2);
+    expect(features[0].title).toBe('Fast Search');
+  });
+
+  it('extracts from docs before specification', () => {
+    const docs = `# Product\n## Features\n- **Real Feature** - From docs`;
+    const spec = `## Features\n- Implement login page\n- Fix CSS bug`;
+    const features = extractFeatures(docs, spec);
+    // Should use docs features, not spec dev tasks
+    expect(features[0].title).toBe('Real Feature');
+  });
+
+  it('falls back to specification when docs have no features', () => {
+    const docs = `# Product\n## About\nJust a description.`;
+    const spec = `## Core Design Principles\n1. **Vector DB agnostic**\n2. **Embedding agnostic**`;
+    const features = extractFeatures(docs, spec);
+    expect(features.length).toBeGreaterThanOrEqual(2);
+    expect(features[0].title).toContain('Vector DB');
+  });
+
+  it('filters out dev-task verbs', () => {
+    const docs = `# Tasks\n## Features\n- Implement user auth\n- Fix broken login\n- **Real Feature** - Does real stuff\n- Refactor database layer`;
+    const features = extractFeatures(docs);
+    // Dev tasks should be filtered out
+    expect(features.some(f => f.title.startsWith('Implement'))).toBe(false);
+    expect(features.some(f => f.title.startsWith('Fix'))).toBe(false);
+    expect(features.some(f => f.title.startsWith('Refactor'))).toBe(false);
+    // Real feature should remain
+    expect(features.some(f => f.title === 'Real Feature')).toBe(true);
+  });
+
+  it('returns empty when no feature sections exist', () => {
+    const docs = `# README\nJust a readme file.`;
+    const features = extractFeatures(docs);
+    expect(features).toEqual([]);
+  });
+
+  it('limits features to 6', () => {
+    const items = Array.from({ length: 10 }, (_, i) => `- **Feature ${i + 1}** - Description ${i + 1}`).join('\n');
+    const docs = `## Features\n${items}`;
+    const features = extractFeatures(docs);
+    expect(features.length).toBeLessThanOrEqual(6);
+  });
+});
+
+describe('extractProductName', () => {
+  it('extracts from "# Name -- tagline" heading', () => {
+    const docs = '# Gateco -- Permission-Aware Retrieval';
+    expect(extractProductName(docs)).toBe('Gateco');
+  });
+
+  it('picks shortest name when multiple headings', () => {
+    const docs = '# Gateco -- main product\n# Gateco UI Color System -- colors';
+    expect(extractProductName(docs)).toBe('Gateco');
+  });
+
+  it('returns undefined when no match', () => {
+    expect(extractProductName('Just some text')).toBeUndefined();
+  });
+});
+
+describe('extractPrimaryColor', () => {
+  it('extracts accent-primary token', () => {
+    const docs = '| `accent-primary` | `#2563EB` | Primary CTA |';
+    expect(extractPrimaryColor(docs)).toBe('#2563EB');
+  });
+
+  it('skips dark background colors', () => {
+    const docs = '| bg | #0F172A |\n| accent-primary | #2563EB |';
+    expect(extractPrimaryColor(docs)).toBe('#2563EB');
+  });
+});
+
+describe('isSuspiciousProductName', () => {
+  it('flags directory-like names', () => {
+    expect(isSuspiciousProductName('my-cool-project')).toBe(true);
+    expect(isSuspiciousProductName('my-app')).toBe(true);
+  });
+
+  it('allows real product names', () => {
+    expect(isSuspiciousProductName('Gateco')).toBe(false);
+    expect(isSuspiciousProductName('SuperApp')).toBe(false);
+  });
+});
+
+describe('extractPricing', () => {
+  it('extracts pricing tiers from markdown table', () => {
+    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');
+  });
+
+  it('returns undefined when no pricing found', () => {
+    const docs = '# Product\nJust a product.';
+    expect(extractPricing(docs)).toBeUndefined();
+  });
+});

package/tests/generators/frontend-design-analyzer.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Tests for frontend design language analyzer
+ * Verifies CSS variable extraction, component library detection, and tailwind parsing
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { analyzeFrontendDesign } from '../../src/generators/frontend-design-analyzer.js';
+
+describe('analyzeFrontendDesign', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-fe-design-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns null when no frontend app directory exists', async () => {
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).toBeNull();
+  });
+
+  it('extracts CSS custom properties from index.css', async () => {
+    const frontendDir = path.join(tmpDir, 'apps', 'frontend', 'src');
+    await fs.mkdir(frontendDir, { recursive: true });
+    await fs.writeFile(
+      path.join(frontendDir, 'index.css'),
+      `:root {
+  --primary: 222.2 47.4% 11.2%;
+  --radius: 0.5rem;
+}
+
+.dark {
+  --primary: 210 40% 98%;
+}
+`
+    );
+    // Need package.json for component lib detection
+    await fs.writeFile(
+      path.join(tmpDir, 'apps', 'frontend', 'package.json'),
+      JSON.stringify({ dependencies: { '@shadcn/ui': '^1.0.0' } })
+    );
+
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.primaryColor).toBeDefined();
+    expect(result!.borderRadius).toBe('0.5rem');
+    expect(result!.darkMode).toBe(true);
+    expect(result!.source).toBe('css-variables');
+  });
+
+  it('detects shadcn component library from package.json', async () => {
+    const frontendDir = path.join(tmpDir, 'apps', 'frontend');
+    await fs.mkdir(frontendDir, { recursive: true });
+    await fs.writeFile(
+      path.join(frontendDir, 'package.json'),
+      JSON.stringify({
+        dependencies: { '@shadcn/ui': '^1.0.0', react: '^18.0.0' },
+      })
+    );
+
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.componentLibrary).toBe('shadcn');
+  });
+
+  it('detects MUI component library', async () => {
+    const frontendDir = path.join(tmpDir, 'apps', 'frontend');
+    await fs.mkdir(frontendDir, { recursive: true });
+    await fs.writeFile(
+      path.join(frontendDir, 'package.json'),
+      JSON.stringify({
+        dependencies: { '@mui/material': '^5.0.0', react: '^18.0.0' },
+      })
+    );
+
+    const result = await analyzeFrontendDesign(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.componentLibrary).toBe('mui');
+  });
+});

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

@@ -0,0 +1,183 @@
+/**
+ * Tests for website content quality gate
+ * Verifies that validateWebsiteContextOrThrow blocks generic websites
+ * and validateWebsiteContext returns structured soft validation results
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateWebsiteContextOrThrow,
+  validateWebsiteContext,
+} from '../../src/generators/website-context.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+
+function makeContext(overrides: Partial<WebsiteContentContext> = {}): WebsiteContentContext {
+  return {
+    productName: 'Gateco',
+    features: [
+      { title: 'Access Control', description: 'Fine-grained permissions' },
+      { title: 'Vector DB Agnostic', description: 'Works with any vector database' },
+    ],
+    rawDocs: '--- spec.md ---\n# Gateco\nLong enough content to pass validation threshold.\n' + 'x'.repeat(100),
+    strategy: {
+      icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] },
+      positioning: { category: 'Security', differentiators: [], valueProposition: 'Secure AI', proofPoints: [] },
+      messaging: { headline: 'h', subheadline: 's', elevatorPitch: 'e', longDescription: 'l' },
+      seoStrategy: { primaryKeywords: [], secondaryKeywords: [], longTailKeywords: [], titleTemplates: {}, metaDescriptions: {} },
+      siteArchitecture: { pages: [], navigation: [], footerSections: [] },
+      conversionStrategy: { primaryCta: { text: 'Go', href: '/' }, secondaryCta: { text: 'More', href: '/' }, trustSignals: [], socialProof: [], leadCapture: 'none' },
+      competitiveContext: { category: 'sec', competitors: [], differentiators: [] },
+    },
+    ...overrides,
+  };
+}
+
+describe('validateWebsiteContextOrThrow', () => {
+  it('passes validation with valid product context', () => {
+    const context = makeContext();
+
+    expect(() => validateWebsiteContextOrThrow(context, 'gateco')).not.toThrow();
+  });
+
+  it('throws on suspicious product name (directory-like)', () => {
+    const context = makeContext({ productName: 'read-all-files' });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'read-all-files')).toThrow(
+      /looks like a directory name/
+    );
+  });
+
+  it('throws when no docs found', () => {
+    const context = makeContext({ rawDocs: '' });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'test')).toThrow(
+      /No project documentation found/
+    );
+  });
+
+  it('throws when no features extracted', () => {
+    const context = makeContext({ features: [] });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'test')).toThrow(
+      /No product features extracted/
+    );
+  });
+
+  it('includes POPEYE_DEBUG_WEBSITE hint in error message', () => {
+    const context = makeContext({ rawDocs: '' });
+
+    try {
+      validateWebsiteContextOrThrow(context, 'test');
+      expect.fail('Should have thrown');
+    } catch (error) {
+      expect((error as Error).message).toContain('POPEYE_DEBUG_WEBSITE=1');
+    }
+  });
+
+  it('still throws when passed is false from validateWebsiteContext', () => {
+    // Context with multiple blocking issues
+    const context = makeContext({
+      productName: 'my-app',
+      rawDocs: '',
+      features: [],
+      strategy: undefined,
+    });
+
+    expect(() => validateWebsiteContextOrThrow(context, 'my-app')).toThrow(
+      /Website generation blocked/
+    );
+  });
+});
+
+describe('validateWebsiteContext (soft mode)', () => {
+  it('returns passed=true with no issues for valid context', () => {
+    const context = makeContext({ tagline: 'Secure your AI' });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.passed).toBe(true);
+    expect(result.issues).toHaveLength(0);
+    expect(result.contentScore).toBeGreaterThanOrEqual(90);
+  });
+
+  it('returns warnings without marking passed=false', () => {
+    // Valid context but missing tagline triggers a warning, not an issue
+    const context = makeContext({ tagline: undefined });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.passed).toBe(true);
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings.some((w) => /tagline/i.test(w))).toBe(true);
+  });
+
+  it('detects default pricing fingerprint as a warning', () => {
+    const context = makeContext({
+      pricing: [
+        { name: 'Free', price: '$0', description: 'Basic', features: ['1 user'], cta: 'Start' },
+        { name: 'Pro', price: '$29', description: 'Team', features: ['10 users'], cta: 'Go', featured: true },
+        { name: 'Enterprise', price: 'Custom', description: 'Scale', features: ['Unlimited'], cta: 'Contact' },
+      ],
+    });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.passed).toBe(true);
+    expect(result.warnings.some((w) => /default values/i.test(w))).toBe(true);
+  });
+
+  it('does not flag custom pricing as default', () => {
+    const context = makeContext({
+      pricing: [
+        { name: 'Hobby', price: '$9', description: 'For side projects', features: ['5 APIs'], cta: 'Start' },
+        { name: 'Team', price: '$49', description: 'For teams', features: ['50 APIs'], cta: 'Go' },
+      ],
+    });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.warnings.some((w) => /default values/i.test(w))).toBe(false);
+  });
+
+  it('decreases contentScore with more defaults', () => {
+    const minimal = makeContext({
+      tagline: undefined,
+      description: undefined,
+      brand: undefined,
+    });
+    const rich = makeContext({
+      tagline: 'Secure your AI',
+      description: 'The best AI security platform',
+      brand: { primaryColor: '#3B82F6' },
+    });
+
+    const minResult = validateWebsiteContext(minimal, 'gateco');
+    const richResult = validateWebsiteContext(rich, 'gateco');
+
+    expect(richResult.contentScore).toBeGreaterThan(minResult.contentScore);
+  });
+
+  it('returns blocking issues for missing docs', () => {
+    const context = makeContext({ rawDocs: '' });
+    const result = validateWebsiteContext(context, 'test');
+
+    expect(result.passed).toBe(false);
+    expect(result.issues.some((i) => /documentation/i.test(i))).toBe(true);
+  });
+
+  it('warns about missing description', () => {
+    const context = makeContext({ description: undefined });
+    const result = validateWebsiteContext(context, 'gateco');
+
+    expect(result.warnings.some((w) => /description/i.test(w))).toBe(true);
+  });
+
+  it('clamps score to 0 when everything is wrong', () => {
+    const context: WebsiteContentContext = {
+      productName: 'my-app',
+      features: [],
+      rawDocs: '',
+      strategy: undefined,
+    };
+    const result = validateWebsiteContext(context, 'my-app');
+
+    expect(result.contentScore).toBe(0);
+    expect(result.passed).toBe(false);
+  });
+});