popeye-cli 1.2.1 → 1.4.0

package/src/workflow/workspace-manager.ts

@@ -1,6 +1,6 @@
 /**
  * Workspace manager module
- * Handles loading, saving, and querying workspace configuration for fullstack projects
+ * Handles loading, saving, and querying workspace configuration for fullstack/all projects
  * Also provides app-specific context for AI reviews
  */
 
@@ -9,11 +9,16 @@ import path from 'node:path';
 import type { WorkspaceConfig, WorkspaceApp } from '../types/project.js';
 import type { ReviewAppTarget } from '../types/consensus.js';
 
+/**
+ * App name type for workspace apps
+ */
+export type WorkspaceAppName = 'frontend' | 'backend' | 'website';
+
 /**
  * Context for AI review of a specific app
  */
 export interface AppReviewContext {
-  appName: 'frontend' | 'backend';
+  appName: WorkspaceAppName;
   language: 'python' | 'typescript';
   path: string;
   /** Key source files content for review */
@@ -29,11 +34,12 @@ export interface AppReviewContext {
 }
 
 /**
- * Combined review context for fullstack projects
+ * Combined review context for fullstack/all projects
  */
 export interface FullstackReviewContext {
   frontend?: AppReviewContext;
   backend?: AppReviewContext;
+  website?: AppReviewContext;
   /** Shared contracts (OpenAPI spec) */
   contracts?: string;
   /** Project-level context */
@@ -109,14 +115,14 @@ export class WorkspaceManager {
   /**
    * Get a specific app configuration
    */
-  getApp(appName: 'frontend' | 'backend'): WorkspaceApp | undefined {
+  getApp(appName: WorkspaceAppName): WorkspaceApp | undefined {
     return this.config?.apps[appName];
   }
 
   /**
    * Get the absolute path to an app
    */
-  getAppPath(appName: 'frontend' | 'backend'): string | null {
+  getAppPath(appName: WorkspaceAppName): string | null {
     const app = this.getApp(appName);
     if (!app) return null;
     return path.join(this.projectDir, app.path);
@@ -125,18 +131,19 @@ export class WorkspaceManager {
   /**
    * Get all app names
    */
-  getAppNames(): ('frontend' | 'backend')[] {
+  getAppNames(): WorkspaceAppName[] {
     if (!this.config) return [];
-    const names: ('frontend' | 'backend')[] = [];
+    const names: WorkspaceAppName[] = [];
     if (this.config.apps.frontend) names.push('frontend');
     if (this.config.apps.backend) names.push('backend');
+    if (this.config.apps.website) names.push('website');
     return names;
   }
 
   /**
    * Get test command for a specific app
    */
-  getTestCommand(appName: 'frontend' | 'backend'): string | null {
+  getTestCommand(appName: WorkspaceAppName): string | null {
     const app = this.getApp(appName);
     return app?.commands.test ?? null;
   }
@@ -172,7 +179,7 @@ export class WorkspaceManager {
   /**
    * Get lint command for a specific app
    */
-  getLintCommand(appName: 'frontend' | 'backend'): string | null {
+  getLintCommand(appName: WorkspaceAppName): string | null {
     const app = this.getApp(appName);
     return app?.commands.lint ?? null;
   }
@@ -208,7 +215,7 @@ export class WorkspaceManager {
   /**
    * Get build command for a specific app
    */
-  getBuildCommand(appName: 'frontend' | 'backend'): string | null {
+  getBuildCommand(appName: WorkspaceAppName): string | null {
     const app = this.getApp(appName);
     return app?.commands.build ?? null;
   }
@@ -244,7 +251,7 @@ export class WorkspaceManager {
   /**
    * Get dev command for a specific app
    */
-  getDevCommand(appName: 'frontend' | 'backend'): string | null {
+  getDevCommand(appName: WorkspaceAppName): string | null {
     const app = this.getApp(appName);
     return app?.commands.dev ?? null;
   }
@@ -288,7 +295,7 @@ export class WorkspaceManager {
   /**
    * Get context roots for an app (files to include in AI context)
    */
-  getContextRoots(appName: 'frontend' | 'backend'): string[] {
+  getContextRoots(appName: WorkspaceAppName): string[] {
     const app = this.getApp(appName);
     if (!app || !app.contextRoots) return [];
 
@@ -315,7 +322,7 @@ export class WorkspaceManager {
   /**
    * Get app language
    */
-  getAppLanguage(appName: 'frontend' | 'backend'): 'python' | 'typescript' | null {
+  getAppLanguage(appName: WorkspaceAppName): 'python' | 'typescript' | null {
     const app = this.getApp(appName);
     return app?.language ?? null;
   }
@@ -323,7 +330,7 @@ export class WorkspaceManager {
   /**
    * Determine which app should handle a file based on path
    */
-  getAppForFile(filePath: string): 'frontend' | 'backend' | null {
+  getAppForFile(filePath: string): WorkspaceAppName | null {
     const relativePath = path.relative(this.projectDir, filePath);
 
     for (const appName of this.getAppNames()) {
@@ -341,7 +348,7 @@ export class WorkspaceManager {
    * Reads key files from contextRoots to provide to AI reviewers
    */
   async getAppReviewContext(
-    appName: 'frontend' | 'backend',
+    appName: WorkspaceAppName,
     options: {
       maxFiles?: number;
       maxFileSize?: number;
@@ -406,7 +413,8 @@ export class WorkspaceManager {
 
     // Read test files
     if (includeTests) {
-      const testDir = path.join(appPath, appName === 'frontend' ? 'src' : 'tests');
+      // Frontend and website use 'src' for tests, backend uses 'tests'
+      const testDir = path.join(appPath, (appName === 'frontend' || appName === 'website') ? 'src' : 'tests');
       try {
         const testFiles = await this.findTestFiles(testDir, app.language);
         context.testFiles = testFiles.slice(0, 5); // Limit test files
@@ -464,6 +472,15 @@ export class WorkspaceManager {
       context.backend = backend;
     }
 
+    // Get website context (for 'all' projects)
+    const website = await this.getAppReviewContext('website', {
+      maxFiles: maxFilesPerApp,
+      includeTests,
+    });
+    if (website) {
+      context.website = website;
+    }
+
     // Get shared contracts
     const contractsPath = this.getContractsPath();
     if (contractsPath) {
@@ -527,7 +544,7 @@ export class WorkspaceManager {
   }
 
   /**
-   * Format fullstack context for review prompt
+   * Format fullstack/all context for review prompt
    */
   formatFullstackContextForReview(context: FullstackReviewContext): string {
     const lines: string[] = [];
@@ -554,21 +571,26 @@ export class WorkspaceManager {
       lines.push(this.formatContextForReview(context.backend));
     }
 
+    if (context.website) {
+      lines.push(this.formatContextForReview(context.website));
+    }
+
     return lines.join('\n');
   }
 
   /**
    * Determine review app target based on plan content
-   * Analyzes plan text to determine if it's frontend, backend, or unified
+   * Analyzes plan text to determine if it's frontend, backend, website, or unified
    */
   categorizeByPlanContent(planContent: string): ReviewAppTarget {
     const lowerContent = planContent.toLowerCase();
 
-    // Frontend indicators
+    // Frontend indicators (app frontend - React/Vue components)
     const frontendKeywords = [
       'react', 'component', 'jsx', 'tsx', 'css', 'tailwind', 'ui',
-      'button', 'form', 'page', 'layout', 'style', 'vite', 'frontend',
+      'button', 'form', 'layout', 'style', 'vite', 'frontend',
       'client', 'browser', 'dom', 'render', 'hook', 'state',
+      'apps/frontend',
     ];
 
     // Backend indicators
@@ -576,12 +598,24 @@ export class WorkspaceManager {
       'api', 'endpoint', 'route', 'database', 'model', 'schema',
       'fastapi', 'flask', 'django', 'express', 'server', 'backend',
       'authentication', 'middleware', 'orm', 'sql', 'query', 'crud',
+      'apps/backend',
+    ];
+
+    // Website indicators (marketing/landing pages, SEO)
+    const websiteKeywords = [
+      'website', 'landing', 'marketing', 'seo', 'meta', 'sitemap',
+      'static', 'astro', 'next', 'gatsby', 'blog', 'content',
+      'apps/website', '[web]', 'web page', 'homepage',
     ];
 
     const frontendScore = frontendKeywords.filter(kw => lowerContent.includes(kw)).length;
     const backendScore = backendKeywords.filter(kw => lowerContent.includes(kw)).length;
+    const websiteScore = websiteKeywords.filter(kw => lowerContent.includes(kw)).length;
 
-    // Threshold for classification
+    // Threshold for classification - check website first as it's most specific
+    if (websiteScore > Math.max(frontendScore, backendScore) && websiteScore >= 2) {
+      return 'website';
+    }
     if (frontendScore > backendScore * 2 && frontendScore >= 3) {
       return 'frontend';
     }
@@ -682,9 +716,9 @@ export class WorkspaceManager {
    * Get feedback document paths for workspace
    */
   getFeedbackPaths(): {
-    master: { unified: string; frontend: string; backend: string };
-    getMilestonePaths: (milestoneId: string) => { unified: string; frontend: string; backend: string };
-    getTaskPaths: (milestoneId: string, taskId: string) => { unified: string; frontend: string; backend: string };
+    master: { unified: string; frontend: string; backend: string; website: string };
+    getMilestonePaths: (milestoneId: string) => { unified: string; frontend: string; backend: string; website: string };
+    getTaskPaths: (milestoneId: string, taskId: string) => { unified: string; frontend: string; backend: string; website: string };
   } {
     const plansDir = path.join(this.projectDir, 'docs', 'plans');
 
@@ -693,16 +727,19 @@ export class WorkspaceManager {
         unified: path.join(plansDir, 'master', 'unified', 'feedback.md'),
         frontend: path.join(plansDir, 'master', 'frontend', 'feedback.md'),
         backend: path.join(plansDir, 'master', 'backend', 'feedback.md'),
+        website: path.join(plansDir, 'master', 'website', 'feedback.md'),
       },
       getMilestonePaths: (milestoneId: string) => ({
         unified: path.join(plansDir, `milestone-${milestoneId}`, 'unified', 'feedback.md'),
         frontend: path.join(plansDir, `milestone-${milestoneId}`, 'frontend', 'feedback.md'),
         backend: path.join(plansDir, `milestone-${milestoneId}`, 'backend', 'feedback.md'),
+        website: path.join(plansDir, `milestone-${milestoneId}`, 'website', 'feedback.md'),
       }),
       getTaskPaths: (milestoneId: string, taskId: string) => ({
         unified: path.join(plansDir, `milestone-${milestoneId}`, 'tasks', `task-${taskId}`, 'unified', 'feedback.md'),
         frontend: path.join(plansDir, `milestone-${milestoneId}`, 'tasks', `task-${taskId}`, 'frontend', 'feedback.md'),
         backend: path.join(plansDir, `milestone-${milestoneId}`, 'tasks', `task-${taskId}`, 'backend', 'feedback.md'),
+        website: path.join(plansDir, `milestone-${milestoneId}`, 'tasks', `task-${taskId}`, 'website', 'feedback.md'),
       }),
     };
   }
@@ -745,12 +782,12 @@ export async function isWorkspaceProject(projectDir: string): Promise<boolean> {
  * Get app context for AI code generation
  *
  * @param projectDir - Project directory
- * @param appName - App name
+ * @param appName - App name (frontend, backend, or website)
  * @returns Object with app info and context files
  */
 export async function getAppContext(
   projectDir: string,
-  appName: 'frontend' | 'backend'
+  appName: WorkspaceAppName
 ): Promise<{
   app: WorkspaceApp | undefined;
   language: 'python' | 'typescript' | null;
@@ -818,12 +855,12 @@ export async function getBuildCommands(projectDir: string): Promise<{
  * Get app-specific review context
  *
  * @param projectDir - Project directory
- * @param appName - App name (frontend or backend)
+ * @param appName - App name (frontend, backend, or website)
  * @returns Review context with source files and metadata
  */
 export async function getAppReviewContext(
   projectDir: string,
-  appName: 'frontend' | 'backend'
+  appName: WorkspaceAppName
 ): Promise<AppReviewContext | null> {
   const manager = new WorkspaceManager(projectDir);
   const config = await manager.load();
@@ -899,9 +936,9 @@ export async function categorizePlanContent(
  * @returns Object with feedback path getters
  */
 export async function getWorkspaceFeedbackPaths(projectDir: string): Promise<{
-  master: { unified: string; frontend: string; backend: string };
-  getMilestonePaths: (milestoneId: string) => { unified: string; frontend: string; backend: string };
-  getTaskPaths: (milestoneId: string, taskId: string) => { unified: string; frontend: string; backend: string };
+  master: { unified: string; frontend: string; backend: string; website: string };
+  getMilestonePaths: (milestoneId: string) => { unified: string; frontend: string; backend: string; website: string };
+  getTaskPaths: (milestoneId: string, taskId: string) => { unified: string; frontend: string; backend: string; website: string };
 } | null> {
   const manager = new WorkspaceManager(projectDir);
   const config = await manager.load();

package/tests/cli/model-command.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Tests for model command validation logic
+ * Tests the schemas and validation used by handleModel
+ */
+
+import { describe, it, expect } from 'vitest';
+import { OpenAIModelSchema, KNOWN_OPENAI_MODELS } from '../../src/types/project.js';
+import { GeminiModelSchema, GrokModelSchema, KNOWN_GEMINI_MODELS } from '../../src/types/consensus.js';
+
+describe('OpenAI model validation', () => {
+  it('should accept known OpenAI models', () => {
+    for (const model of KNOWN_OPENAI_MODELS) {
+      expect(OpenAIModelSchema.safeParse(model).success).toBe(true);
+    }
+  });
+
+  it('should accept unknown/new OpenAI models (flexible)', () => {
+    expect(OpenAIModelSchema.safeParse('gpt-5').success).toBe(true);
+    expect(OpenAIModelSchema.safeParse('gpt-5.2-turbo').success).toBe(true);
+    expect(OpenAIModelSchema.safeParse('o3-mini').success).toBe(true);
+  });
+
+  it('should reject empty string', () => {
+    expect(OpenAIModelSchema.safeParse('').success).toBe(false);
+  });
+});
+
+describe('Gemini model validation', () => {
+  it('should accept known Gemini models', () => {
+    for (const model of KNOWN_GEMINI_MODELS) {
+      expect(GeminiModelSchema.safeParse(model).success).toBe(true);
+    }
+  });
+
+  it('should accept unknown/new Gemini models (flexible)', () => {
+    expect(GeminiModelSchema.safeParse('gemini-2.5-pro').success).toBe(true);
+    expect(GeminiModelSchema.safeParse('gemini-3.0-ultra').success).toBe(true);
+  });
+
+  it('should reject empty string', () => {
+    expect(GeminiModelSchema.safeParse('').success).toBe(false);
+  });
+});
+
+describe('Grok model validation', () => {
+  it('should accept any non-empty string as Grok model', () => {
+    expect(GrokModelSchema.safeParse('grok-3').success).toBe(true);
+    expect(GrokModelSchema.safeParse('grok-3-mini').success).toBe(true);
+    expect(GrokModelSchema.safeParse('grok-2').success).toBe(true);
+    expect(GrokModelSchema.safeParse('some-future-model').success).toBe(true);
+  });
+
+  it('should accept empty string with default', () => {
+    // GrokModelSchema has a default, so empty parse gets default
+    const result = GrokModelSchema.safeParse(undefined);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toBe('grok-3');
+    }
+  });
+});
+
+describe('known models lists', () => {
+  it('should have known OpenAI models', () => {
+    expect(KNOWN_OPENAI_MODELS).toContain('gpt-4o');
+    expect(KNOWN_OPENAI_MODELS).toContain('gpt-4o-mini');
+    expect(KNOWN_OPENAI_MODELS.length).toBeGreaterThanOrEqual(5);
+  });
+
+  it('should have known Gemini models', () => {
+    expect(KNOWN_GEMINI_MODELS).toContain('gemini-2.0-flash');
+    expect(KNOWN_GEMINI_MODELS).toContain('gemini-1.5-pro');
+    expect(KNOWN_GEMINI_MODELS.length).toBeGreaterThanOrEqual(3);
+  });
+});
+
+describe('backward compatibility', () => {
+  it('should auto-detect known OpenAI models from bare name', () => {
+    // Simulating the backward-compat logic in handleModel
+    for (const model of KNOWN_OPENAI_MODELS) {
+      const isKnown = (KNOWN_OPENAI_MODELS as readonly string[]).includes(model);
+      expect(isKnown).toBe(true);
+    }
+  });
+
+  it('should not auto-detect non-OpenAI models as known OpenAI', () => {
+    const nonOpenAI = ['gemini-2.0-flash', 'grok-3'];
+    for (const model of nonOpenAI) {
+      const isKnown = (KNOWN_OPENAI_MODELS as readonly string[]).includes(model);
+      expect(isKnown).toBe(false);
+    }
+  });
+});

package/tests/types/project.test.ts

@@ -7,7 +7,11 @@ import {
   ProjectSpecSchema,
   OutputLanguageSchema,
   OpenAIModelSchema,
+  isWorkspace,
+  languageToApps,
+  hasApp,
 } from '../../src/types/project.js';
+import type { OutputLanguage } from '../../src/types/project.js';
 
 describe('ProjectSpecSchema', () => {
   describe('valid inputs', () => {
@@ -78,11 +82,22 @@ describe('ProjectSpecSchema', () => {
       expect(result.success).toBe(false);
     });
 
-    it('should reject invalid OpenAI model', () => {
+    it('should accept new/custom OpenAI model names', () => {
       const spec = {
         idea: 'Build something great',
         language: 'python',
-        openaiModel: 'invalid-model',
+        openaiModel: 'gpt-5.2-turbo',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(true);
+    });
+
+    it('should reject empty OpenAI model', () => {
+      const spec = {
+        idea: 'Build something great',
+        language: 'python',
+        openaiModel: '',
       };
 
       const result = ProjectSpecSchema.safeParse(spec);
@@ -101,14 +116,12 @@ describe('ProjectSpecSchema', () => {
 });
 
 describe('OutputLanguageSchema', () => {
-  it('should accept python', () => {
-    const result = OutputLanguageSchema.safeParse('python');
-    expect(result.success).toBe(true);
-  });
-
-  it('should accept typescript', () => {
-    const result = OutputLanguageSchema.safeParse('typescript');
-    expect(result.success).toBe(true);
+  it('should accept all 5 valid languages', () => {
+    const validLanguages = ['python', 'typescript', 'fullstack', 'website', 'all'];
+    for (const lang of validLanguages) {
+      const result = OutputLanguageSchema.safeParse(lang);
+      expect(result.success).toBe(true);
+    }
   });
 
   it('should reject invalid language', () => {
@@ -117,18 +130,80 @@ describe('OutputLanguageSchema', () => {
   });
 });
 
+describe('isWorkspace', () => {
+  it('should return true for fullstack', () => {
+    expect(isWorkspace('fullstack')).toBe(true);
+  });
+
+  it('should return true for all', () => {
+    expect(isWorkspace('all')).toBe(true);
+  });
+
+  it('should return false for python', () => {
+    expect(isWorkspace('python')).toBe(false);
+  });
+
+  it('should return false for typescript', () => {
+    expect(isWorkspace('typescript')).toBe(false);
+  });
+
+  it('should return false for website', () => {
+    expect(isWorkspace('website')).toBe(false);
+  });
+});
+
+describe('languageToApps', () => {
+  it('should return backend for python', () => {
+    expect(languageToApps('python')).toEqual(['backend']);
+  });
+
+  it('should return frontend for typescript', () => {
+    expect(languageToApps('typescript')).toEqual(['frontend']);
+  });
+
+  it('should return frontend and backend for fullstack', () => {
+    expect(languageToApps('fullstack')).toEqual(['frontend', 'backend']);
+  });
+
+  it('should return website for website', () => {
+    expect(languageToApps('website')).toEqual(['website']);
+  });
+
+  it('should return all three for all', () => {
+    expect(languageToApps('all')).toEqual(['frontend', 'backend', 'website']);
+  });
+});
+
+describe('hasApp', () => {
+  it('should detect backend in python', () => {
+    expect(hasApp('python', 'backend')).toBe(true);
+    expect(hasApp('python', 'frontend')).toBe(false);
+  });
+
+  it('should detect all apps in all', () => {
+    expect(hasApp('all', 'frontend')).toBe(true);
+    expect(hasApp('all', 'backend')).toBe(true);
+    expect(hasApp('all', 'website')).toBe(true);
+  });
+});
+
 describe('OpenAIModelSchema', () => {
-  it('should accept all valid models', () => {
-    const validModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
+  it('should accept known models', () => {
+    const knownModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
 
-    for (const model of validModels) {
+    for (const model of knownModels) {
       const result = OpenAIModelSchema.safeParse(model);
       expect(result.success).toBe(true);
     }
   });
 
-  it('should reject invalid model', () => {
-    const result = OpenAIModelSchema.safeParse('gpt-5');
+  it('should accept new/unknown models (flexible)', () => {
+    expect(OpenAIModelSchema.safeParse('gpt-5').success).toBe(true);
+    expect(OpenAIModelSchema.safeParse('gpt-5.2-turbo').success).toBe(true);
+  });
+
+  it('should reject empty string', () => {
+    const result = OpenAIModelSchema.safeParse('');
     expect(result.success).toBe(false);
   });
 });

package/tests/types/workflow-schema.test.ts

@@ -0,0 +1,59 @@
+/**
+ * Tests for ProjectStateSchema accepting all 5 language types
+ */
+
+import { describe, it, expect } from 'vitest';
+import { ProjectStateSchema } from '../../src/types/workflow.js';
+
+/**
+ * Minimal valid project state for testing schema validation
+ */
+function makeMinimalState(language: string) {
+  return {
+    id: 'test-id',
+    name: 'test-project',
+    idea: 'A test project idea that is long enough',
+    language,
+    openaiModel: 'gpt-4o',
+    phase: 'plan',
+    status: 'pending',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+describe('ProjectStateSchema language validation', () => {
+  it('should accept python', () => {
+    const result = ProjectStateSchema.safeParse(makeMinimalState('python'));
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept typescript', () => {
+    const result = ProjectStateSchema.safeParse(makeMinimalState('typescript'));
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept fullstack', () => {
+    const result = ProjectStateSchema.safeParse(makeMinimalState('fullstack'));
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept website', () => {
+    const result = ProjectStateSchema.safeParse(makeMinimalState('website'));
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept all', () => {
+    const result = ProjectStateSchema.safeParse(makeMinimalState('all'));
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid language', () => {
+    const result = ProjectStateSchema.safeParse(makeMinimalState('java'));
+    expect(result.success).toBe(false);
+  });
+});