popeye-cli 2.2.0 → 2.7.0

package/src/generators/website-content-ai.ts

@@ -0,0 +1,186 @@
+/**
+ * AI Website Content Generator — fills missing website content
+ * when doc parser fails to extract tagline/description/features/pricing.
+ *
+ * Uses OpenAI gpt-4.1 with Zod-validated JSON response.
+ * Includes pricing hallucination guard to prevent inventing prices
+ * without evidence in source docs.
+ */
+
+import { z } from 'zod';
+
+// ─── Types ───────────────────────────────────────────────
+
+export interface AIContentResult {
+  tagline?: string;
+  description?: string;
+  features?: Array<{ title: string; description: string; icon?: string }>;
+  pricing?: Array<{
+    name: string;
+    price: string;
+    period?: string;
+    description: string;
+    features: string[];
+    cta: string;
+    featured?: boolean;
+  }>;
+}
+
+// ─── Response Schema ─────────────────────────────────────
+
+const AIContentResponseSchema = z.object({
+  tagline: z.string().optional(),
+  description: z.string().optional(),
+  features: z.array(z.object({
+    title: z.string(),
+    description: z.string(),
+    icon: z.string().optional(),
+  })).optional(),
+  pricing: z.array(z.object({
+    name: z.string(),
+    price: z.string(),
+    period: z.string().optional(),
+    description: z.string(),
+    features: z.array(z.string()),
+    cta: z.string().default('Get Started'),
+    featured: z.boolean().optional(),
+  })).optional(),
+});
+
+// ─── Pricing Hallucination Guard ─────────────────────────
+
+/** Broad pricing evidence detection */
+const PRICING_EVIDENCE = /\$\d|€\d|£\d|USD\s*\d|\d+\s*\/\s*mo|per\s*month|monthly|yearly|\/yr|per\s*year|pricing\s*(?:plan|tier|model)|subscription|free\s*(?:plan|tier)/i;
+
+/** Pattern that detects numeric pricing in AI output */
+const NUMERIC_PRICING_PATTERN = /[\$€£]\d|USD\s*\d|\d+\s*\/\s*mo/;
+
+/**
+ * Check if source docs contain evidence of pricing information.
+ *
+ * Args:
+ *   rawDocs: Combined documentation content.
+ *   specification: Expanded specification text.
+ *
+ * Returns:
+ *   true if pricing evidence is found in either source.
+ */
+export function hasPricingEvidence(rawDocs: string, specification: string): boolean {
+  return PRICING_EVIDENCE.test(rawDocs) || PRICING_EVIDENCE.test(specification);
+}
+
+/**
+ * Post-validate AI-generated pricing to prevent hallucinated prices.
+ * If no pricing evidence exists in source docs, reject any numeric prices.
+ * "Free" is always allowed (low risk).
+ *
+ * Args:
+ *   pricing: AI-generated pricing array.
+ *   hasEvidence: Whether pricing evidence was found in source docs.
+ *
+ * Returns:
+ *   Sanitized pricing array (empty if hallucinated prices detected).
+ */
+function sanitizePricing(
+  pricing: NonNullable<AIContentResult['pricing']>,
+  hasEvidence: boolean,
+): AIContentResult['pricing'] {
+  if (hasEvidence) return pricing;
+
+  // No evidence — check if AI invented numeric prices
+  const hasNumericPrices = pricing.some(
+    (tier) => NUMERIC_PRICING_PATTERN.test(tier.price),
+  );
+
+  if (hasNumericPrices) {
+    // Reject entire pricing array — AI hallucinated prices
+    return undefined;
+  }
+
+  // Allow "Free", "TBD", "Contact us" etc.
+  return pricing;
+}
+
+// ─── AI Content Generation ──────────────────────────────
+
+/**
+ * Generate missing website content using AI.
+ * Single OpenAI gpt-4.1 call with Zod-validated JSON response.
+ * Non-blocking: returns empty {} on any failure.
+ *
+ * Args:
+ *   productName: The product name.
+ *   specification: Expanded specification text.
+ *   rawDocs: Combined documentation content.
+ *
+ * Returns:
+ *   AIContentResult with any fields the AI could generate.
+ */
+export async function generateMissingWebsiteContent(
+  productName: string,
+  specification: string,
+  rawDocs: string,
+): Promise<AIContentResult> {
+  try {
+    const hasEvidence = hasPricingEvidence(rawDocs, specification);
+
+    const pricingInstruction = hasEvidence
+      ? 'Infer pricing tiers from the documentation. Use exact prices if mentioned.'
+      : 'Set all prices to "Contact us" or "TBD". Do not invent numeric pricing.';
+
+    const systemPrompt = [
+      'You are a marketing content expert. Generate website content for a software product.',
+      'Return a JSON object with these fields (all optional):',
+      '- tagline: short marketing tagline (max 80 chars)',
+      '- description: product description (max 200 chars)',
+      '- features: array of {title, description, icon?} (3-6 features, icon is a lucide icon name)',
+      '- pricing: array of {name, price, period?, description, features[], cta, featured?} (2-4 tiers, cta is the button text like "Get Started")',
+      '',
+      `PRICING RULES: ${pricingInstruction}`,
+      '',
+      'Base all content on the product documentation provided. Do not invent facts.',
+      'Return ONLY valid JSON, no markdown or explanation.',
+    ].join('\n');
+
+    const userPrompt = [
+      `Product: ${productName}`,
+      '',
+      specification ? `Specification:\n${specification.slice(0, 3000)}` : '',
+      '',
+      rawDocs ? `Documentation:\n${rawDocs.slice(0, 5000)}` : '',
+    ].filter(Boolean).join('\n');
+
+    const { createClient } = await import('../adapters/openai.js');
+    const client = await createClient();
+    const completion = await client.chat.completions.create({
+      model: 'gpt-4.1',
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+      temperature: 0.3,
+      response_format: { type: 'json_object' },
+    });
+    const response = completion.choices[0]?.message?.content ?? '{}';
+
+    // Parse and validate response
+    const parsed = JSON.parse(response);
+    const validated = AIContentResponseSchema.safeParse(parsed);
+
+    if (!validated.success) {
+      return {};
+    }
+
+    const result: AIContentResult = { ...validated.data };
+
+    // Apply pricing hallucination guard
+    if (result.pricing && result.pricing.length > 0) {
+      result.pricing = sanitizePricing(result.pricing, hasEvidence);
+    }
+
+    return result;
+  } catch {
+    // Non-blocking: return empty on any failure
+    return {};
+  }
+}

package/src/generators/website-content-scanner.ts

@@ -76,6 +76,16 @@ const PLACEHOLDER_PATTERNS: Array<{
     message: 'Default pricing amount ($29/mo)',
     severity: 'warning',
   },
+  {
+    pattern: /coming soon/i,
+    message: 'Contains "coming soon" placeholder text',
+    severity: 'error',
+  },
+  {
+    pattern: /placeholder/i,
+    message: 'Contains "placeholder" text',
+    severity: 'error',
+  },
 ];
 
 /**
@@ -156,7 +166,100 @@ function findLineNumber(content: string, pattern: RegExp): number | undefined {
 }
 
 /**
- * Scan generated website files for placeholder fingerprints
+ * Collect all page routes from the src/app directory structure.
+ * A route exists if there is a page.tsx (or page.jsx/page.ts/page.js) in a directory.
+ *
+ * @param appDir - The src/app directory path
+ * @returns Set of route paths (e.g., '/', '/pricing', '/blog')
+ */
+async function collectPageRoutes(appDir: string): Promise<Set<string>> {
+  const routes = new Set<string>();
+
+  async function walk(dir: string, routePrefix: string): Promise<void> {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      // Check if this directory has a page file
+      const hasPage = entries.some(
+        (e) => e.isFile() && /^page\.(tsx|jsx|ts|js)$/.test(e.name)
+      );
+      if (hasPage) {
+        routes.add(routePrefix || '/');
+      }
+
+      // Recurse into subdirectories (skip special dirs)
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith('_') || entry.name === 'api' || SKIP_DIRS.has(entry.name)) continue;
+        await walk(path.join(dir, entry.name), `${routePrefix}/${entry.name}`);
+      }
+    } catch {
+      // Directory not accessible
+    }
+  }
+
+  await walk(appDir, '');
+  return routes;
+}
+
+/**
+ * Scan for internal links that point to pages that do not exist.
+ *
+ * @param websiteDir - The website project directory
+ * @param files - Already-collected source file paths
+ * @returns Array of scan issues for broken internal links
+ */
+async function scanInternalLinks(
+  websiteDir: string,
+  files: string[]
+): Promise<ScanIssue[]> {
+  const issues: ScanIssue[] = [];
+  const appDir = path.join(websiteDir, 'src', 'app');
+
+  // Collect existing page routes
+  const routes = await collectPageRoutes(appDir);
+
+  // Regex to find href="/..." values in source files
+  const hrefPattern = /href=["'](\/([\w-/]*)?)["']/g;
+
+  for (const filePath of files) {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const relativePath = path.relative(websiteDir, filePath);
+
+      let match;
+      while ((match = hrefPattern.exec(content)) !== null) {
+        const href = match[1];
+
+        // Skip anchor links (/#section), API routes, and external/protocol links
+        if (href.startsWith('/#') || href.startsWith('/api/') || href.startsWith('/api')) continue;
+
+        // Normalize: strip trailing slash for comparison
+        const normalizedHref = href === '/' ? '/' : href.replace(/\/$/, '');
+
+        if (!routes.has(normalizedHref)) {
+          const lineNum = content.slice(0, match.index).split('\n').length;
+          issues.push({
+            file: relativePath,
+            message: `Internal link "${href}" points to a page that does not exist`,
+            severity: 'error',
+            line: lineNum,
+          });
+        }
+      }
+
+      // Reset regex lastIndex for next file
+      hrefPattern.lastIndex = 0;
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Scan generated website files for placeholder fingerprints and broken internal links
  *
  * @param websiteDir - The website project directory to scan
  * @returns Scan result with issues and quality score
@@ -200,6 +303,15 @@ export async function scanGeneratedContent(websiteDir: string): Promise<ScanResu
     }
   }
 
+  // Scan for broken internal links
+  try {
+    const linkIssues = await scanInternalLinks(websiteDir, files);
+    issues.push(...linkIssues);
+    score -= linkIssues.length * 15;
+  } catch {
+    // Non-blocking: link scan failures should not stop the overall scan
+  }
+
   return {
     issues,
     filesScanned: files.length,

package/src/generators/website-context.ts

@@ -17,10 +17,17 @@ import {
 } from './doc-parser.js';
 import { getScanDirectories } from './workspace-root.js';
 import type { WebsiteStrategyDocument, BrandAssetsContract } from '../types/website-strategy.js';
+import { generateMissingWebsiteContent } from './website-content-ai.js';
 
 /** Per-file character cap to prevent a single large doc from consuming the budget */
 const PER_FILE_CAP = 8000;
 
+/** Allowed extensions for user-provided doc paths */
+const ALLOWED_DOC_EXTENSIONS = ['.md', '.mdx', '.txt'];
+
+/** Maximum file size for user-provided docs (2MB) */
+const MAX_DOC_SIZE = 2 * 1024 * 1024;
+
 /**
  * Structured content context for website generation
  */
@@ -48,6 +55,15 @@ export interface WebsiteContentContext {
   strategy?: WebsiteStrategyDocument;
   /** Resolved brand assets contract for deterministic logo/favicon placement */
   brandAssets?: BrandAssetsContract;
+  /** Diagnostics for pricing extraction pipeline */
+  pricingDiagnostics?: {
+    charsScanned: number;
+    foundPricingHeader: boolean;
+    extractionMethod: 'known_plan_names' | 'table_fallback' | 'ai' | 'none';
+    extractedTiers?: Array<{ name: string; price: string }>;
+    reasonIfEmpty?: string;
+    source: 'docs' | 'ai' | 'default' | 'none';
+  };
 }
 
 /**
@@ -279,20 +295,104 @@ export async function readProjectDocs(
   return sections.join('\n\n');
 }
 
+/**
+ * Extract absolute file paths from user-provided text (idea/specification).
+ * Supports:
+ * - Unix paths: '/path/to/file.md'
+ * - Windows paths: "C:\Users\me\file.md"
+ * - Paths with spaces: '/Users/me/My Docs/pricing.md'
+ * - Extensions: .md, .mdx, .txt
+ *
+ * @param text - User-provided idea or specification text
+ * @returns Array of absolute file paths found in the text
+ */
+export function extractDocPathsFromText(text: string): string[] {
+  const paths: string[] = [];
+
+  // 1. Quoted paths (most reliable — handles spaces, cross-platform)
+  const quotedPattern = /['"]([A-Za-z]:[\\\/].+?\.(?:md|mdx|txt)|\/[^'"]+\.(?:md|mdx|txt))['"]/gi;
+  let match;
+  while ((match = quotedPattern.exec(text)) !== null) {
+    paths.push(match[1]);
+  }
+
+  // 2. Unquoted Unix absolute paths (no spaces — spaces break word boundaries)
+  const unquotedUnix = /(?:^|\s)(\/\S+\.(?:md|mdx|txt))(?=[\s,;)]|$)/gm;
+  while ((match = unquotedUnix.exec(text)) !== null) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+
+  // 3. Unquoted Windows paths (drive letter)
+  const unquotedWin = /(?:^|\s)([A-Za-z]:[\\\/]\S+\.(?:md|mdx|txt))(?=[\s,;)]|$)/gm;
+  while ((match = unquotedWin.exec(text)) !== null) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+
+  return [...new Set(paths)];
+}
+
+/**
+ * Validate and filter doc paths for safe ingestion.
+ * Checks: isAbsolute, file exists, size < 2MB, extension allowed.
+ *
+ * @param paths - Array of absolute paths to validate
+ * @returns Array of valid, readable paths
+ */
+export async function validateAndFilterDocPaths(paths: string[]): Promise<string[]> {
+  const valid: string[] = [];
+  for (const p of paths) {
+    const ext = path.extname(p).toLowerCase();
+    if (!ALLOWED_DOC_EXTENSIONS.includes(ext)) {
+      console.log(`[doc-ingest] Skipped: ${p} (unsupported format ${ext})`);
+      continue;
+    }
+    const isAbs = path.isAbsolute(p) || /^[A-Za-z]:[\\\/]/.test(p);
+    if (!isAbs) continue;
+    try {
+      const stat = await fs.stat(p);
+      if (stat.size > MAX_DOC_SIZE) {
+        console.log(`[doc-ingest] Skipped: ${p} (${(stat.size / 1024).toFixed(0)}KB exceeds 2MB limit)`);
+        continue;
+      }
+      console.log(`[doc-ingest] Read: ${p} (${(stat.size / 1024).toFixed(1)}KB)`);
+      valid.push(p);
+    } catch {
+      console.log(`[doc-ingest] Skipped: ${p} (file not found)`);
+    }
+  }
+  return valid;
+}
+
 /**
  * Build a structured website content context from discovered docs
  *
  * @param cwd - Working directory to scan for docs
  * @param projectName - The project name (folder name fallback)
  * @param specification - Optional expanded specification text
+ * @param extraDocPaths - Optional extra doc paths extracted from user idea text
  * @returns Structured content context for website templates
  */
 export async function buildWebsiteContext(
   cwd: string,
   projectName: string,
-  specification?: string
+  specification?: string,
+  extraDocPaths?: string[],
 ): Promise<WebsiteContentContext> {
   const docPaths = await discoverProjectDocs(cwd);
+
+  // Merge validated extra doc paths (from idea text)
+  if (extraDocPaths?.length) {
+    const validPaths = await validateAndFilterDocPaths(extraDocPaths);
+    const seen = new Set(docPaths.map((p) => path.resolve(p)));
+    for (const p of validPaths) {
+      const resolved = path.resolve(p);
+      if (!seen.has(resolved)) {
+        docPaths.push(resolved);
+        seen.add(resolved);
+      }
+    }
+  }
+
   const rawDocs = docPaths.length > 0 ? await readProjectDocs(docPaths) : '';
   const brandAssets = await findBrandAssets(cwd);
 
@@ -307,7 +407,20 @@ export async function buildWebsiteContext(
 
   context.tagline = extractTagline(cleanDocs, context.productName);
   context.description = extractDescription(cleanDocs, specification);
-  context.pricing = extractPricing(cleanDocs);
+
+  // Extract pricing with provenance tracking
+  const pricingResult = extractPricing(cleanDocs);
+  context.pricing = pricingResult.tiers.length > 0 ? pricingResult.tiers : undefined;
+  context.pricingDiagnostics = {
+    charsScanned: cleanDocs.length,
+    foundPricingHeader: !!cleanDocs.match(/##\s+(?:[\d.]*\s*)?Pricing\b/i),
+    extractionMethod: pricingResult.evidence?.extractionMethod ?? 'none',
+    extractedTiers: pricingResult.tiers.map((t) => ({ name: t.name, price: t.price })),
+    reasonIfEmpty: pricingResult.tiers.length === 0
+      ? 'No pricing table rows matched in docs'
+      : undefined,
+    source: pricingResult.source,
+  };
 
   // Extract brand info
   if (brandAssets.logoPath) {
@@ -319,6 +432,36 @@ export async function buildWebsiteContext(
     context.brand = { ...context.brand, primaryColor };
   }
 
+  // v2.2.2: Per-field AI content generation fallback
+  // Reason: triggers when ANY field is missing (not all-or-nothing), but only fills missing fields
+  const pricingMissing = context.pricing == null || context.pricing.length === 0;
+  const hasMissingContent = !context.tagline || !context.description || context.features.length === 0 || pricingMissing;
+  if (hasMissingContent && (rawDocs.length > 50 || specification)) {
+    try {
+      const aiContent = await generateMissingWebsiteContent(
+        context.productName,
+        specification ?? '',
+        rawDocs,
+      );
+      // Only fill fields that are actually missing (don't overwrite extracted truth)
+      if (!context.tagline && aiContent.tagline) context.tagline = aiContent.tagline;
+      if (!context.description && aiContent.description) context.description = aiContent.description;
+      if (context.features.length === 0 && aiContent.features?.length) context.features = aiContent.features;
+      if (pricingMissing && aiContent.pricing?.length) {
+        context.pricing = aiContent.pricing;
+        context.pricingDiagnostics = {
+          ...context.pricingDiagnostics!,
+          extractionMethod: 'ai',
+          source: 'ai',
+          extractedTiers: aiContent.pricing.map((t) => ({ name: t.name, price: t.price })),
+          reasonIfEmpty: undefined,
+        };
+      }
+    } catch {
+      // Non-blocking: continue with doc-parser results
+    }
+  }
+
   return context;
 }
 
@@ -388,14 +531,6 @@ export function validateWebsiteContext(
     contentScore -= 20;
   }
 
-  // Strategy validation
-  if (!context.strategy) {
-    issues.push(
-      'Website strategy missing. Strategy generation may have failed or been skipped.'
-    );
-    contentScore -= 15;
-  }
-
   // Brand color validation: brand/color docs exist but no color extracted
   if (!context.brand?.primaryColor && context.rawDocs && /color|brand/i.test(context.rawDocs)) {
     issues.push(
@@ -421,8 +556,12 @@ export function validateWebsiteContext(
     const nameMatches = tierNames.filter((n) => DEFAULT_PRICING_NAMES.includes(n));
     const priceMatches = tierPrices.filter((p) => DEFAULT_PRICING_AMOUNTS.includes(p));
 
-    // Reason: if most tier names AND prices match defaults, it's likely placeholder content
-    if (nameMatches.length >= 2 && priceMatches.length >= 2) {
+    // Reason: only warn when pricing did NOT come from docs or AI (provenance-based check)
+    const pricingSource = context.pricingDiagnostics?.source;
+    if (
+      nameMatches.length >= 2 && priceMatches.length >= 2
+      && pricingSource !== 'docs' && pricingSource !== 'ai'
+    ) {
       warnings.push(
         'Pricing tiers appear to use default values (Starter/Pro/Enterprise at $0/$29/Custom). ' +
         'Add a pricing section to your docs for accurate tiers.'

package/src/generators/website-debug.ts

@@ -23,6 +23,15 @@ export interface WebsiteDebugTrace {
     dataSource: 'strategy' | 'docs' | 'defaults' | 'skipped';
     itemCount: number;
   }>;
+  /** Pricing extraction diagnostics */
+  pricingDiagnostics?: {
+    charsScanned: number;
+    foundPricingHeader: boolean;
+    extractionMethod: 'known_plan_names' | 'table_fallback' | 'ai' | 'none';
+    extractedTiers?: Array<{ name: string; price: string }>;
+    reasonIfEmpty?: string;
+    source: 'docs' | 'ai' | 'default' | 'none';
+  };
   /** Validation result from quality gate */
   validationPassed: boolean;
   validationIssues: string[];
@@ -104,6 +113,23 @@ export function formatDebugTrace(trace: WebsiteDebugTrace): string {
   }
   lines.push('');
 
+  if (trace.pricingDiagnostics) {
+    lines.push('Pricing Diagnostics:');
+    lines.push(`  Source: ${trace.pricingDiagnostics.source}`);
+    lines.push(`  Method: ${trace.pricingDiagnostics.extractionMethod}`);
+    lines.push(`  Chars Scanned: ${trace.pricingDiagnostics.charsScanned}`);
+    lines.push(`  Found Header: ${trace.pricingDiagnostics.foundPricingHeader}`);
+    if (trace.pricingDiagnostics.extractedTiers?.length) {
+      for (const t of trace.pricingDiagnostics.extractedTiers) {
+        lines.push(`  - ${t.name}: ${t.price}`);
+      }
+    }
+    if (trace.pricingDiagnostics.reasonIfEmpty) {
+      lines.push(`  Reason empty: ${trace.pricingDiagnostics.reasonIfEmpty}`);
+    }
+    lines.push('');
+  }
+
   lines.push(`Validation: ${trace.validationPassed ? 'PASSED' : 'FAILED'}`);
   if (trace.validationIssues.length > 0) {
     for (const issue of trace.validationIssues) {

package/src/generators/website.ts

@@ -16,6 +16,9 @@ import {
   generateWebsiteTest,
   generateWebsiteDocsPage,
   generateWebsiteBlogPage,
+  generateWebsiteContactPage,
+  generateWebsitePrivacyPage,
+  generateWebsiteTermsPage,
 } from './templates/website.js';
 import {
   generateWebsitePackageJson,
@@ -134,6 +137,9 @@ export async function generateWebsiteProject(
     await ensureDir(path.join(projectDir, 'src', 'app', 'pricing'));
     await ensureDir(path.join(projectDir, 'src', 'app', 'docs'));
     await ensureDir(path.join(projectDir, 'src', 'app', 'blog'));
+    await ensureDir(path.join(projectDir, 'src', 'app', 'contact'));
+    await ensureDir(path.join(projectDir, 'src', 'app', 'privacy'));
+    await ensureDir(path.join(projectDir, 'src', 'app', 'terms'));
     await ensureDir(path.join(projectDir, 'src', 'app', 'api', 'lead'));
     await ensureDir(path.join(projectDir, 'src', 'components'));
     await ensureDir(path.join(projectDir, 'src', 'lib'));
@@ -187,6 +193,7 @@ export async function generateWebsiteProject(
           pricingTiers: contentContext.pricing?.length || 0,
         },
         sectionsRendered: [],
+        pricingDiagnostics: contentContext.pricingDiagnostics,
         validationPassed: true,
         validationIssues: [],
       };
@@ -206,7 +213,10 @@ export async function generateWebsiteProject(
       },
       {
         path: path.join(projectDir, 'tsconfig.json'),
-        content: generateWebsiteTsconfig(),
+        content: generateWebsiteTsconfig({
+          workspaceMode,
+          projectName: workspaceMode ? projectName : undefined,
+        }),
       },
       {
         path: path.join(projectDir, 'tailwind.config.ts'),
@@ -248,11 +258,23 @@ export async function generateWebsiteProject(
       },
       {
         path: path.join(projectDir, 'src', 'app', 'docs', 'page.tsx'),
-        content: generateWebsiteDocsPage(),
+        content: generateWebsiteDocsPage(projectName, contentContext),
       },
       {
         path: path.join(projectDir, 'src', 'app', 'blog', 'page.tsx'),
-        content: generateWebsiteBlogPage(),
+        content: generateWebsiteBlogPage(projectName, contentContext),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'contact', 'page.tsx'),
+        content: generateWebsiteContactPage(projectName, contentContext),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'privacy', 'page.tsx'),
+        content: generateWebsitePrivacyPage(projectName, contentContext),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'terms', 'page.tsx'),
+        content: generateWebsiteTermsPage(projectName, contentContext),
       },
 
       // Shared components
@@ -462,6 +484,9 @@ export function getWebsiteProjectFiles(_projectName: string): string[] {
     'src/app/pricing/page.tsx',
     'src/app/docs/page.tsx',
     'src/app/blog/page.tsx',
+    'src/app/contact/page.tsx',
+    'src/app/privacy/page.tsx',
+    'src/app/terms/page.tsx',
     'src/app/sitemap.ts',
     'src/app/robots.ts',
     // Tests