popeye-cli 1.4.6 → 1.5.0

package/src/types/website-strategy.ts

@@ -0,0 +1,243 @@
+/**
+ * Website strategy type definitions
+ * Defines the strategic marketing document, site architecture,
+ * design tokens, and brand assets contract for website generation
+ */
+
+import { z } from 'zod';
+
+/**
+ * Navigation item for site header/footer
+ */
+export interface NavItem {
+  label: string;
+  href: string;
+  children?: NavItem[];
+}
+
+/**
+ * Footer section with links
+ */
+export interface FooterSection {
+  title: string;
+  links: Array<{ label: string; href: string }>;
+}
+
+/**
+ * Page definition in site architecture
+ */
+export interface SiteArchitecturePage {
+  path: string;
+  title: string;
+  purpose: string;
+  pageType:
+    | 'landing'
+    | 'pricing'
+    | 'solution'
+    | 'use-cases'
+    | 'about'
+    | 'contact'
+    | 'blog'
+    | 'docs'
+    | 'legal';
+  sections: string[];
+  seoKeywords: string[];
+  conversionGoal: string;
+}
+
+/**
+ * Complete website strategy document
+ * Generated by AI from product context, user docs, and market inputs
+ */
+export interface WebsiteStrategyDocument {
+  icp: {
+    primaryPersona: string;
+    painPoints: string[];
+    goals: string[];
+    objections: string[];
+  };
+  positioning: {
+    category: string;
+    differentiators: string[];
+    valueProposition: string;
+    proofPoints: string[];
+  };
+  messaging: {
+    headline: string;
+    subheadline: string;
+    elevatorPitch: string;
+    longDescription: string;
+  };
+  seoStrategy: {
+    primaryKeywords: string[];
+    secondaryKeywords: string[];
+    longTailKeywords: string[];
+    titleTemplates: Record<string, string>;
+    metaDescriptions: Record<string, string>;
+  };
+  siteArchitecture: {
+    pages: SiteArchitecturePage[];
+    navigation: NavItem[];
+    footerSections: FooterSection[];
+  };
+  conversionStrategy: {
+    primaryCta: { text: string; href: string };
+    secondaryCta: { text: string; href: string };
+    trustSignals: string[];
+    socialProof: string[];
+    leadCapture: 'none' | 'webhook' | 'resend' | 'postmark';
+  };
+  competitiveContext: {
+    category: string;
+    competitors: string[];
+    differentiators: string[];
+  };
+}
+
+/**
+ * Strategy metadata for caching and staleness detection
+ */
+export interface StrategyMetadata {
+  /** SHA-256 of (docs + spec + tokens) for staleness detection */
+  inputHash: string;
+  /** ISO timestamp of generation */
+  generatedAt: string;
+  /** Schema version */
+  version: number;
+}
+
+/**
+ * Design tokens extracted from project config or brand docs
+ */
+export interface DesignTokens {
+  colors: Record<string, string>;
+  fonts: { heading: string; body: string; mono?: string };
+  borderRadius: string;
+  source: 'tailwind-config' | 'css-variables' | 'brand-docs' | 'defaults';
+}
+
+/**
+ * Brand assets contract for deterministic logo/favicon placement
+ */
+export interface BrandAssetsContract {
+  /** Discovered source path for logo */
+  logoPath?: string;
+  /** Canonical output path: public/brand/logo.{ext} */
+  logoOutputPath: string;
+  /** Discovered source path for favicon */
+  faviconPath?: string;
+  /** Primary brand color */
+  primaryColor?: string;
+  /** Full color scheme */
+  colorScheme?: Record<string, string>;
+}
+
+// --- Zod Schemas ---
+
+export const NavItemSchema: z.ZodType<NavItem> = z.lazy(() =>
+  z.object({
+    label: z.string().min(1),
+    href: z.string().min(1),
+    children: z.array(NavItemSchema).optional(),
+  })
+);
+
+export const FooterSectionSchema = z.object({
+  title: z.string().min(1),
+  links: z.array(
+    z.object({
+      label: z.string().min(1),
+      href: z.string().min(1),
+    })
+  ),
+});
+
+export const SiteArchitecturePageSchema = z.object({
+  path: z.string().min(1),
+  title: z.string().min(1),
+  purpose: z.string(),
+  pageType: z.enum([
+    'landing',
+    'pricing',
+    'solution',
+    'use-cases',
+    'about',
+    'contact',
+    'blog',
+    'docs',
+    'legal',
+  ]),
+  sections: z.array(z.string()),
+  seoKeywords: z.array(z.string()),
+  conversionGoal: z.string(),
+});
+
+export const WebsiteStrategySchema = z.object({
+  icp: z.object({
+    primaryPersona: z.string().min(1),
+    painPoints: z.array(z.string()),
+    goals: z.array(z.string()),
+    objections: z.array(z.string()),
+  }),
+  positioning: z.object({
+    category: z.string().min(1),
+    differentiators: z.array(z.string()),
+    valueProposition: z.string().min(1),
+    proofPoints: z.array(z.string()),
+  }),
+  messaging: z.object({
+    headline: z.string().min(1),
+    subheadline: z.string().min(1),
+    elevatorPitch: z.string().min(1),
+    longDescription: z.string().min(1),
+  }),
+  seoStrategy: z.object({
+    primaryKeywords: z.array(z.string()),
+    secondaryKeywords: z.array(z.string()),
+    longTailKeywords: z.array(z.string()),
+    titleTemplates: z.record(z.string(), z.string()),
+    metaDescriptions: z.record(z.string(), z.string()),
+  }),
+  siteArchitecture: z.object({
+    pages: z.array(SiteArchitecturePageSchema),
+    navigation: z.array(NavItemSchema),
+    footerSections: z.array(FooterSectionSchema),
+  }),
+  conversionStrategy: z.object({
+    primaryCta: z.object({ text: z.string().min(1), href: z.string().min(1) }),
+    secondaryCta: z.object({ text: z.string().min(1), href: z.string().min(1) }),
+    trustSignals: z.array(z.string()),
+    socialProof: z.array(z.string()),
+    leadCapture: z.enum(['none', 'webhook', 'resend', 'postmark']),
+  }),
+  competitiveContext: z.object({
+    category: z.string(),
+    competitors: z.array(z.string()),
+    differentiators: z.array(z.string()),
+  }),
+});
+
+export const StrategyMetadataSchema = z.object({
+  inputHash: z.string().min(1),
+  generatedAt: z.string().min(1),
+  version: z.number(),
+});
+
+export const DesignTokensSchema = z.object({
+  colors: z.record(z.string(), z.string()),
+  fonts: z.object({
+    heading: z.string(),
+    body: z.string(),
+    mono: z.string().optional(),
+  }),
+  borderRadius: z.string(),
+  source: z.enum(['tailwind-config', 'css-variables', 'brand-docs', 'defaults']),
+});
+
+export const BrandAssetsContractSchema = z.object({
+  logoPath: z.string().optional(),
+  logoOutputPath: z.string().min(1),
+  faviconPath: z.string().optional(),
+  primaryColor: z.string().optional(),
+  colorScheme: z.record(z.string(), z.string()).optional(),
+});

package/src/types/workflow.ts

@@ -192,6 +192,15 @@ export interface ProjectState {
   error?: string;
   createdAt: string;
   updatedAt: string;
+  /** Raw user documentation discovered from CWD */
+  userDocs?: string;
+  /** Brand context discovered from CWD */
+  brandContext?: {
+    logoPath?: string;
+    primaryColor?: string;
+  };
+  /** Path to website strategy JSON file (relative to .popeye/) */
+  websiteStrategy?: string;
 }
 
 /**
@@ -229,6 +238,12 @@ export const ProjectStateSchema = z.object({
   error: z.string().optional(),
   createdAt: z.string(),
   updatedAt: z.string(),
+  userDocs: z.string().optional(),
+  brandContext: z.object({
+    logoPath: z.string().optional(),
+    primaryColor: z.string().optional(),
+  }).optional(),
+  websiteStrategy: z.string().optional(),
 });
 
 /**

package/src/workflow/auto-fix.ts

@@ -6,6 +6,59 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { executePrompt } from '../adapters/claude.js';
+import { isWorkspace, type OutputLanguage } from '../types/project.js';
+
+/** Standard workspace subdirectories to search when a file isn't at the root */
+const WORKSPACE_SUBDIRS = ['apps/frontend', 'apps/backend', 'apps/website', 'packages/frontend', 'packages/backend'];
+
+/**
+ * Resolve a (possibly relative) error file path to an absolute path that exists on disk.
+ * For workspace projects, if the file doesn't exist at the project root, searches
+ * workspace subdirectories (apps/frontend, apps/backend, etc.).
+ */
+export async function resolveErrorFilePath(
+  filePath: string,
+  projectDir: string,
+  language: string,
+): Promise<string> {
+  // If already absolute and exists, use it directly
+  if (path.isAbsolute(filePath)) {
+    try {
+      await fs.access(filePath);
+      return filePath;
+    } catch {
+      // Absolute path doesn't exist — for workspace projects, try searching subdirs
+      if (!isWorkspace(language as OutputLanguage)) return filePath;
+      const basename = path.basename(filePath);
+      for (const subdir of WORKSPACE_SUBDIRS) {
+        const candidate = path.join(projectDir, subdir, basename);
+        try {
+          await fs.access(candidate);
+          return candidate;
+        } catch { /* continue */ }
+      }
+      return filePath;
+    }
+  }
+
+  // Relative path: try at project root first
+  const rootPath = path.join(projectDir, filePath);
+  try {
+    await fs.access(rootPath);
+    return rootPath;
+  } catch {
+    // Not at root — for workspace projects, search subdirs
+    if (!isWorkspace(language as OutputLanguage)) return rootPath;
+    for (const subdir of WORKSPACE_SUBDIRS) {
+      const candidate = path.join(projectDir, subdir, filePath);
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch { /* continue */ }
+    }
+    return rootPath;
+  }
+}
 
 /**
  * Build error details
@@ -180,7 +233,8 @@ export async function autoFixTypeScriptErrors(
   projectDir: string,
   buildOutput: string,
   maxAttempts: number = 3,
-  onProgress?: (message: string) => void
+  onProgress?: (message: string) => void,
+  language: string = 'typescript',
 ): Promise<AutoFixResult> {
   const fixes: Array<{ file: string; description: string }> = [];
   let attempts = 0;
@@ -237,7 +291,7 @@ export async function autoFixTypeScriptErrors(
 
     // Fix each file
     for (const [filePath, fileErrors] of errorsByFile) {
-      const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(projectDir, filePath);
+      const absolutePath = await resolveErrorFilePath(filePath, projectDir, language);
 
       try {
         // Read current file content
@@ -401,7 +455,7 @@ export async function buildWithAutoFix(
 
     // Try auto-fix for TypeScript-based projects (includes fullstack, website, all)
     if (isTypeScriptBased) {
-      const fixResult = await autoFixTypeScriptErrors(projectDir, output, maxAttempts, onProgress);
+      const fixResult = await autoFixTypeScriptErrors(projectDir, output, maxAttempts, onProgress, language);
 
       // Log structural issue if detected
       if (fixResult.isStructuralIssue) {

package/src/workflow/consensus.ts

@@ -79,6 +79,7 @@ async function requestReviewerConsensus(
       model: config.geminiModel,
       temperature: config.temperature,
       maxTokens: config.maxTokens,
+      reviewerPersona: config.reviewerPersona,
     });
   }
   if (reviewer === 'grok') {
@@ -86,6 +87,7 @@ async function requestReviewerConsensus(
       model: config.grokModel,
       temperature: config.temperature,
       maxTokens: config.maxTokens,
+      reviewerPersona: config.reviewerPersona,
     });
   }
   return requestOpenAIConsensus(plan, context, config);

package/src/workflow/execution-mode.ts

@@ -782,6 +782,14 @@ function buildTaskContext(
 ): string {
   const lines: string[] = [];
 
+  // No-hardcode enforcement rule
+  lines.push('## CRITICAL RULES');
+  lines.push('- NEVER use hardcoded placeholder content, mock data, or invented copy.');
+  lines.push('- ALL text, features, pricing, colors, and data MUST come from the project specification and user documentation below.');
+  lines.push('- If information is not available in the spec, leave a TODO comment rather than inventing content.');
+  lines.push('- Do NOT hallucinate product names, features, pricing tiers, testimonials, or blog content.');
+  lines.push('');
+
   lines.push(`## Project: ${state.name}`);
   lines.push(`Language: ${state.language}`);
   lines.push('');
@@ -798,6 +806,19 @@ function buildTaskContext(
     lines.push('');
   }
 
+  // Include user documentation if available
+  if (state.userDocs) {
+    lines.push('## Project Documentation');
+    lines.push(state.userDocs.slice(0, 3000));
+    lines.push('');
+  }
+
+  // Include brand context if available
+  if (state.brandContext?.primaryColor) {
+    lines.push(`## Brand: Primary color ${state.brandContext.primaryColor}`);
+    lines.push('');
+  }
+
   // Include UI design context if available
   if (uiDesignContext) {
     lines.push(uiDesignContext);

package/src/workflow/index.ts

@@ -50,6 +50,9 @@ export * from './task-workflow.js';
 export * from './milestone-workflow.js';
 export * from './plan-storage.js';
 export * from './workspace-manager.js';
+export * from './website-updater.js';
+export * from './website-strategy.js';
+export * from './overview.js';
 
 /**
  * Workflow options
@@ -116,6 +119,17 @@ export async function runWorkflow(
       };
     }
 
+    // Post-plan: Update website content with project context
+    if (spec.language === 'website' || spec.language === 'all' || spec.language === 'fullstack') {
+      try {
+        onProgress?.('website-update', 'Updating website with project context...');
+        const { updateWebsiteContent } = await import('./website-updater.js');
+        await updateWebsiteContent(projectDir, planResult.state, spec.language, (msg) => onProgress?.('website-update', msg));
+      } catch {
+        // Non-blocking: website content update failure should not stop workflow
+      }
+    }
+
     // Phase 2: Execution Mode
     onProgress?.('workflow', 'Starting Execution Mode...');
 
@@ -224,6 +238,17 @@ export async function resumeWorkflow(
           };
         }
 
+        // Post-plan: Update website content with project context
+        if (state.language === 'website' || state.language === 'all' || state.language === 'fullstack') {
+          try {
+            onProgress?.('website-update', 'Updating website with project context...');
+            const { updateWebsiteContent } = await import('./website-updater.js');
+            await updateWebsiteContent(projectDir, planResult.state, state.language, (msg) => onProgress?.('website-update', msg));
+          } catch {
+            // Non-blocking
+          }
+        }
+
         // Continue to execution
         onProgress?.('workflow', 'Starting Execution Mode...');