popeye-cli 1.2.1 → 1.4.0

package/src/generators/website.ts

@@ -0,0 +1,350 @@
+/**
+ * Website project generator
+ * Creates SEO-ready Next.js marketing website
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import type { ProjectSpec } from '../types/project.js';
+import {
+  generateWebsitePackageJson,
+  generateNextConfig,
+  generateWebsiteTsconfig,
+  generateWebsiteTailwindConfig,
+  generateWebsitePostcssConfig,
+  generateWebsiteLayout,
+  generateWebsiteGlobalsCss,
+  generateWebsiteLandingPage,
+  generateWebsitePricingPage,
+  generateWebsiteSitemap,
+  generateWebsiteRobots,
+  generateWebsiteDockerfile,
+  generateWebsiteReadme,
+  generateWebsiteSpec,
+  generateWebsiteVitestConfig,
+  generateWebsiteVitestSetup,
+  generateWebsiteTest,
+  generateWebsiteDocsPage,
+  generateWebsiteBlogPage,
+  generateWebsiteNextEnv,
+} from './templates/website.js';
+
+/**
+ * Project generation result
+ */
+export interface GenerationResult {
+  success: boolean;
+  projectDir: string;
+  filesCreated: string[];
+  error?: string;
+}
+
+/**
+ * Website generator options for workspace/monorepo support
+ */
+export interface WebsiteGeneratorOptions {
+  /** Base directory for project (defaults to outputDir/projectName) */
+  baseDir?: string;
+  /** Override auto-derived package name */
+  packageName?: string;
+  /** Adjust paths for monorepo structure */
+  workspaceMode?: boolean;
+  /** Skip Docker files (fullstack uses root docker-compose) */
+  skipDocker?: boolean;
+  /** Skip README (fullstack has root README) */
+  skipReadme?: boolean;
+}
+
+/**
+ * Create a directory if it doesn't exist
+ */
+async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Write a file with content
+ */
+async function writeFile(filePath: string, content: string): Promise<void> {
+  await fs.writeFile(filePath, content, 'utf-8');
+}
+
+/**
+ * Generate a complete Next.js website project
+ *
+ * @param spec - Project specification
+ * @param outputDir - Output directory
+ * @param options - Generator options for workspace/monorepo support
+ * @returns Generation result
+ */
+export async function generateWebsiteProject(
+  spec: ProjectSpec,
+  outputDir: string,
+  options: WebsiteGeneratorOptions = {}
+): Promise<GenerationResult> {
+  const {
+    baseDir,
+    // packageName reserved for future use
+    workspaceMode = false,
+    skipDocker = false,
+    skipReadme = false,
+  } = options;
+
+  const projectName = spec.name || 'my-project';
+
+  // In workspace mode with baseDir, use it directly; otherwise create subdirectory
+  const projectDir = baseDir || path.join(outputDir, projectName);
+  const filesCreated: string[] = [];
+
+  try {
+    // Create project directory structure
+    await ensureDir(projectDir);
+    await ensureDir(path.join(projectDir, 'src', 'app'));
+    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', 'components'));
+    await ensureDir(path.join(projectDir, 'src', 'lib'));
+    await ensureDir(path.join(projectDir, 'content', 'blog'));
+    await ensureDir(path.join(projectDir, 'content', 'docs'));
+    await ensureDir(path.join(projectDir, 'public'));
+    await ensureDir(path.join(projectDir, 'tests'));
+
+    // Only create .popeye dir in standalone mode
+    if (!workspaceMode) {
+      await ensureDir(path.join(projectDir, '.popeye'));
+    }
+
+    // Generate and write files
+    const files: Array<{ path: string; content: string }> = [
+      // Config files
+      {
+        path: path.join(projectDir, 'package.json'),
+        content: generateWebsitePackageJson(projectName),
+      },
+      {
+        path: path.join(projectDir, 'next.config.mjs'),
+        content: generateNextConfig(),
+      },
+      {
+        path: path.join(projectDir, 'tsconfig.json'),
+        content: generateWebsiteTsconfig(),
+      },
+      {
+        path: path.join(projectDir, 'tailwind.config.ts'),
+        content: generateWebsiteTailwindConfig(),
+      },
+      {
+        path: path.join(projectDir, 'postcss.config.js'),
+        content: generateWebsitePostcssConfig(),
+      },
+      {
+        path: path.join(projectDir, 'vitest.config.ts'),
+        content: generateWebsiteVitestConfig(),
+      },
+      {
+        path: path.join(projectDir, 'next-env.d.ts'),
+        content: generateWebsiteNextEnv(),
+      },
+
+      // App Router files
+      {
+        path: path.join(projectDir, 'src', 'app', 'layout.tsx'),
+        content: generateWebsiteLayout(projectName),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'globals.css'),
+        content: generateWebsiteGlobalsCss(),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'page.tsx'),
+        content: generateWebsiteLandingPage(projectName),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'pricing', 'page.tsx'),
+        content: generateWebsitePricingPage(projectName),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'docs', 'page.tsx'),
+        content: generateWebsiteDocsPage(),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'blog', 'page.tsx'),
+        content: generateWebsiteBlogPage(),
+      },
+
+      // SEO files
+      {
+        path: path.join(projectDir, 'src', 'app', 'sitemap.ts'),
+        content: generateWebsiteSitemap(projectName),
+      },
+      {
+        path: path.join(projectDir, 'src', 'app', 'robots.ts'),
+        content: generateWebsiteRobots(projectName),
+      },
+
+      // Test files
+      {
+        path: path.join(projectDir, 'tests', 'setup.ts'),
+        content: generateWebsiteVitestSetup(),
+      },
+      {
+        path: path.join(projectDir, 'tests', 'page.test.tsx'),
+        content: generateWebsiteTest(projectName),
+      },
+
+      // Placeholder files
+      {
+        path: path.join(projectDir, 'public', '.gitkeep'),
+        content: '',
+      },
+      {
+        path: path.join(projectDir, 'content', 'blog', '.gitkeep'),
+        content: '',
+      },
+      {
+        path: path.join(projectDir, 'content', 'docs', '.gitkeep'),
+        content: '',
+      },
+      {
+        path: path.join(projectDir, 'src', 'components', '.gitkeep'),
+        content: '',
+      },
+      {
+        path: path.join(projectDir, 'src', 'lib', '.gitkeep'),
+        content: '',
+      },
+
+      // Environment
+      {
+        path: path.join(projectDir, '.env.example'),
+        content: 'NEXT_PUBLIC_SITE_URL=http://localhost:3001\nNEXT_PUBLIC_APP_URL=http://localhost:3000\n',
+      },
+      {
+        path: path.join(projectDir, '.gitignore'),
+        content:
+          'node_modules/\n.next/\nout/\n.env\n.env.local\n.env.*.local\ncoverage/\n*.log\n.DS_Store\n',
+      },
+    ];
+
+    // Add website spec in standalone mode
+    if (!workspaceMode) {
+      files.push({
+        path: path.join(projectDir, '.popeye', 'website-spec.json'),
+        content: generateWebsiteSpec(projectName),
+      });
+    }
+
+    // Add README if not skipped
+    if (!skipReadme) {
+      files.push({
+        path: path.join(projectDir, 'README.md'),
+        content: generateWebsiteReadme(projectName),
+      });
+    }
+
+    // Add Docker files if not skipped
+    if (!skipDocker) {
+      files.push({
+        path: path.join(projectDir, 'Dockerfile'),
+        content: generateWebsiteDockerfile(),
+      });
+    }
+
+    // Write all files
+    for (const file of files) {
+      await writeFile(file.path, file.content);
+      filesCreated.push(file.path);
+    }
+
+    return {
+      success: true,
+      projectDir,
+      filesCreated,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      projectDir,
+      filesCreated,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
+
+/**
+ * Get the list of files that would be generated for a website project
+ *
+ * @param _projectName - Project name
+ * @returns List of relative file paths
+ */
+export function getWebsiteProjectFiles(_projectName: string): string[] {
+  return [
+    // Config
+    'package.json',
+    'next.config.mjs',
+    'tsconfig.json',
+    'tailwind.config.ts',
+    'postcss.config.js',
+    'vitest.config.ts',
+    'next-env.d.ts',
+    '.gitignore',
+    '.env.example',
+    'README.md',
+    'Dockerfile',
+    // App Router
+    'src/app/layout.tsx',
+    'src/app/globals.css',
+    'src/app/page.tsx',
+    'src/app/pricing/page.tsx',
+    'src/app/docs/page.tsx',
+    'src/app/blog/page.tsx',
+    'src/app/sitemap.ts',
+    'src/app/robots.ts',
+    // Tests
+    'tests/setup.ts',
+    'tests/page.test.tsx',
+    // Content
+    'content/blog/.gitkeep',
+    'content/docs/.gitkeep',
+    // Spec
+    '.popeye/website-spec.json',
+  ];
+}
+
+/**
+ * Validate a website project structure
+ *
+ * @param projectDir - Project directory
+ * @returns Validation result
+ */
+export async function validateWebsiteProject(projectDir: string): Promise<{
+  valid: boolean;
+  missingFiles: string[];
+}> {
+  const missingFiles: string[] = [];
+
+  const requiredFiles = [
+    'package.json',
+    'next.config.mjs',
+    'tsconfig.json',
+    'src/app/layout.tsx',
+    'src/app/page.tsx',
+    'src/app/sitemap.ts',
+    'src/app/robots.ts',
+  ];
+
+  for (const file of requiredFiles) {
+    const filePath = path.join(projectDir, file);
+    try {
+      await fs.access(filePath);
+    } catch {
+      missingFiles.push(file);
+    }
+  }
+
+  return {
+    valid: missingFiles.length === 0,
+    missingFiles,
+  };
+}

package/src/types/consensus.ts

@@ -5,6 +5,7 @@
 
 import { z } from 'zod';
 import type { OpenAIModel } from './project.js';
+import { OpenAIModelSchema } from './project.js';
 
 /**
  * Supported AI providers for reviews and arbitration
@@ -12,9 +13,9 @@ import type { OpenAIModel } from './project.js';
 export type AIProvider = 'openai' | 'gemini' | 'grok';
 
 /**
- * Supported Gemini models
+ * Gemini model type - flexible string to support new models
  */
-export type GeminiModel = 'gemini-2.0-flash' | 'gemini-1.5-pro' | 'gemini-1.5-flash';
+export type GeminiModel = string;
 
 /**
  * Grok model type (flexible string - API evolves fast)
@@ -115,9 +116,14 @@ export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'gemi
 export const AIProviderSchema = z.enum(['openai', 'gemini', 'grok']);
 
 /**
- * Zod schema for Gemini model
+ * Known Gemini models (used for suggestions and display, not strict validation)
  */
-export const GeminiModelSchema = z.enum(['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash']);
+export const KNOWN_GEMINI_MODELS = ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'] as const;
+
+/**
+ * Zod schema for Gemini model - accepts any non-empty string to support new models
+ */
+export const GeminiModelSchema = z.string().min(1, 'Model name must not be empty');
 
 /**
  * Zod schema for Grok model (flexible string)
@@ -133,7 +139,7 @@ export const ConsensusConfigSchema = z.object({
   openaiKey: z.string().optional(),
   geminiKey: z.string().optional(),
   grokKey: z.string().optional(),
-  openaiModel: z.enum(['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini']),
+  openaiModel: OpenAIModelSchema,
   geminiModel: GeminiModelSchema.default('gemini-2.0-flash'),
   grokModel: GrokModelSchema.default(DEFAULT_GROK_MODEL),
   reviewer: AIProviderSchema.default('openai'),
@@ -195,9 +201,9 @@ export interface EscalationDetails {
 }
 
 /**
- * App target for fullstack reviews
+ * App target for fullstack/all reviews
  */
-export type ReviewAppTarget = 'frontend' | 'backend' | 'unified';
+export type ReviewAppTarget = 'frontend' | 'backend' | 'website' | 'unified';
 
 /**
  * Tagged concern/recommendation with app context
@@ -208,11 +214,12 @@ export interface TaggedItem {
 }
 
 /**
- * Per-app consensus scores for fullstack projects
+ * Per-app consensus scores for fullstack/all projects
  */
 export interface AppConsensusScores {
   frontend?: number;
   backend?: number;
+  website?: number;
   unified: number;  // Combined/overall score
 }
 
@@ -253,6 +260,7 @@ export interface FullstackConsensusIteration extends ConsensusIteration {
   appApproved?: {
     frontend?: boolean;
     backend?: boolean;
+    website?: boolean;
     unified: boolean;
   };
 }
@@ -295,6 +303,10 @@ export interface ConsensusTrackingRecord {
   backendApproved?: boolean;
   backendIterations?: number;
 
+  websiteScore?: number;
+  websiteApproved?: boolean;
+  websiteIterations?: number;
+
   /** All corrections/revisions made */
   corrections: CorrectionRecord[];
 

package/src/types/index.ts

@@ -7,13 +7,31 @@
 export {
   OutputLanguageSchema,
   OpenAIModelSchema,
+  KNOWN_OPENAI_MODELS,
   ProjectSpecSchema,
   OPENAI_MODELS,
+  languageToApps,
+  hasApp,
   type OutputLanguage,
   type OpenAIModel,
   type ProjectSpec,
   type GeneratedProject,
   type GenerationOptions,
+  type AppType,
+  type WorkspaceApp,
+  type WorkspaceAppCommands,
+  type WorkspaceAppDocker,
+  type WorkspaceShared,
+  type WorkspaceCommands,
+  type WorkspaceDocker,
+  type WorkspaceConfig,
+  type WebsiteSpec,
+  type WebsiteBrandColors,
+  type WebsiteTypography,
+  type WebsiteSeo,
+  type WebsitePage,
+  type WebsiteCta,
+  type WebsiteFeatures,
 } from './project.js';
 
 // Workflow types
@@ -37,12 +55,29 @@ export {
 export {
   ConsensusConfigSchema,
   DEFAULT_CONSENSUS_CONFIG,
+  DEFAULT_GROK_MODEL,
+  AIProviderSchema,
+  KNOWN_GEMINI_MODELS,
+  GeminiModelSchema,
+  GrokModelSchema,
+  type AIProvider,
+  type GeminiModel,
+  type GrokModel,
   type ConsensusResult,
   type ConsensusIteration,
   type ConsensusConfig,
   type PlanDocument,
   type ConsensusRequest,
   type EscalationDetails,
+  type ArbitrationResult,
+  type ReviewAppTarget,
+  type TaggedItem,
+  type AppConsensusScores,
+  type AppFeedback,
+  type FullstackConsensusResult,
+  type FullstackConsensusIteration,
+  type CorrectionRecord,
+  type ConsensusTrackingRecord,
 } from './consensus.js';
 
 // CLI types

package/src/types/project.ts

@@ -8,9 +8,66 @@ import { z } from 'zod';
 /**
  * Supported output languages for generated projects
  */
-export const OutputLanguageSchema = z.enum(['python', 'typescript', 'fullstack']);
+/**
+ * Supported output languages for generated projects
+ * - python: Backend only (FastAPI)
+ * - typescript: Frontend only (React/Vite)
+ * - fullstack: FE + BE
+ * - website: Website only (Next.js SSG/SSR)
+ * - all: FE + BE + Website (everything)
+ */
+export const OutputLanguageSchema = z.enum([
+  'python',
+  'typescript',
+  'fullstack',
+  'website',
+  'all',
+]);
 export type OutputLanguage = z.infer<typeof OutputLanguageSchema>;
 
+/**
+ * App types that can be generated
+ */
+export type AppType = 'frontend' | 'backend' | 'website';
+
+/**
+ * Maps a language to the apps it will generate
+ *
+ * @param language - The output language
+ * @returns Array of app types to generate
+ */
+export function languageToApps(language: OutputLanguage): AppType[] {
+  const mapping: Record<OutputLanguage, AppType[]> = {
+    python: ['backend'],
+    typescript: ['frontend'],
+    fullstack: ['frontend', 'backend'],
+    website: ['website'],
+    all: ['frontend', 'backend', 'website'],
+  };
+  return mapping[language];
+}
+
+/**
+ * Checks if a language generates a specific app type
+ *
+ * @param language - The output language
+ * @param app - The app type to check
+ * @returns True if the language generates the app
+ */
+export function hasApp(language: OutputLanguage, app: AppType): boolean {
+  return languageToApps(language).includes(app);
+}
+
+/**
+ * Checks if a language is a workspace type (multi-app monorepo)
+ *
+ * @param language - The output language
+ * @returns True if the language uses workspace/monorepo structure
+ */
+export function isWorkspace(language: OutputLanguage): boolean {
+  return language === 'fullstack' || language === 'all';
+}
+
 /**
  * Commands configuration for a workspace app
  */
@@ -56,6 +113,10 @@ export interface WorkspaceShared {
   contracts?: string;
   /** Generator command for FE client from OpenAPI */
   contractsGenerator?: string;
+  /** Shared UI components package path */
+  ui?: string;
+  /** Design tokens package path */
+  designTokens?: string;
 }
 
 /**
@@ -78,13 +139,14 @@ export interface WorkspaceDocker {
 }
 
 /**
- * Workspace configuration for fullstack projects
+ * Workspace configuration for fullstack/website/all projects
  */
 export interface WorkspaceConfig {
   version: '1.0';
   apps: {
     frontend?: WorkspaceApp;
     backend?: WorkspaceApp;
+    website?: WorkspaceApp;
   };
   shared?: WorkspaceShared;
   /** Repo-level commands that orchestrate across apps */
@@ -93,16 +155,100 @@ export interface WorkspaceConfig {
 }
 
 /**
- * Supported OpenAI models for consensus reviews
+ * Brand colors for website design
  */
-export const OpenAIModelSchema = z.enum([
-  'gpt-4o',
-  'gpt-4o-mini',
-  'gpt-4-turbo',
-  'o1-preview',
-  'o1-mini',
-]);
-export type OpenAIModel = z.infer<typeof OpenAIModelSchema>;
+export interface WebsiteBrandColors {
+  primary: string;
+  secondary: string;
+  accent: string;
+  background: string;
+  foreground: string;
+}
+
+/**
+ * Typography configuration for website
+ */
+export interface WebsiteTypography {
+  headingFont: string;
+  bodyFont: string;
+}
+
+/**
+ * SEO configuration for website
+ */
+export interface WebsiteSeo {
+  title: string;
+  description: string;
+  keywords: string[];
+  ogImage?: string;
+  twitterHandle?: string;
+  locale: string;
+}
+
+/**
+ * Page configuration for website
+ */
+export interface WebsitePage {
+  name: string;
+  path: string;
+  type: 'landing' | 'pricing' | 'docs' | 'blog' | 'changelog' | 'legal';
+  seo?: {
+    title?: string;
+    description?: string;
+  };
+}
+
+/**
+ * Call-to-action configuration
+ */
+export interface WebsiteCta {
+  primary: {
+    text: string;
+    href: string;
+  };
+  secondary?: {
+    text: string;
+    href: string;
+  };
+}
+
+/**
+ * Feature flags for website
+ */
+export interface WebsiteFeatures {
+  analytics?: boolean;
+  newsletter?: boolean;
+  mdxBlog?: boolean;
+  docsSearch?: boolean;
+}
+
+/**
+ * Website specification for Next.js marketing sites
+ */
+export interface WebsiteSpec {
+  version: '1.0';
+  brand: {
+    name: string;
+    tagline?: string;
+    colors: WebsiteBrandColors;
+    typography: WebsiteTypography;
+  };
+  seo: WebsiteSeo;
+  pages: WebsitePage[];
+  cta: WebsiteCta;
+  features?: WebsiteFeatures;
+}
+
+/**
+ * Known OpenAI models (used for suggestions and display, not strict validation)
+ */
+export const KNOWN_OPENAI_MODELS = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'] as const;
+
+/**
+ * OpenAI model schema - accepts any non-empty string to support new models
+ */
+export const OpenAIModelSchema = z.string().min(1, 'Model name must not be empty');
+export type OpenAIModel = string;
 
 /**
  * Project specification provided by user