popeye-cli 1.1.0 → 1.2.0

package/src/config/defaults.ts

@@ -27,6 +27,12 @@ export const DEFAULT_CONFIG: Config = {
     claude: {
       model: 'claude-sonnet-4-20250514',
     },
+    grok: {
+      model: 'grok-3',
+      temperature: 0.3,
+      max_tokens: 4096,
+      api_url: 'https://api.x.ai/v1',
+    },
   },
   project: {
     default_language: 'python',
@@ -92,6 +98,7 @@ export const KEYCHAIN_ACCOUNTS = {
   CLAUDE: 'claude-cli',
   OPENAI: 'openai-api',
   GEMINI: 'gemini-api',
+  GROK: 'grok-api',
 } as const;
 
 /**
@@ -101,9 +108,11 @@ export const ENV_VARS = {
   OPENAI_KEY: 'POPEYE_OPENAI_KEY',
   ANTHROPIC_KEY: 'POPEYE_ANTHROPIC_KEY',
   GEMINI_KEY: 'POPEYE_GEMINI_KEY',
+  GROK_KEY: 'POPEYE_GROK_KEY',
   DEFAULT_LANGUAGE: 'POPEYE_DEFAULT_LANGUAGE',
   OPENAI_MODEL: 'POPEYE_OPENAI_MODEL',
   GEMINI_MODEL: 'POPEYE_GEMINI_MODEL',
+  GROK_MODEL: 'POPEYE_GROK_MODEL',
   CONSENSUS_REVIEWER: 'POPEYE_CONSENSUS_REVIEWER',
   CONSENSUS_ARBITRATOR: 'POPEYE_CONSENSUS_ARBITRATOR',
   CONSENSUS_THRESHOLD: 'POPEYE_CONSENSUS_THRESHOLD',

package/src/config/index.ts

@@ -86,12 +86,26 @@ function loadEnvConfig(): Partial<Config> {
         model: openaiModel as Config['apis']['openai']['model'],
       },
       claude: DEFAULT_CONFIG.apis.claude,
+      grok: DEFAULT_CONFIG.apis.grok,
+    };
+  }
+
+  // Grok model
+  const grokModel = process.env[ENV_VARS.GROK_MODEL];
+  if (grokModel) {
+    config.apis = {
+      ...DEFAULT_CONFIG.apis,
+      ...(config.apis || {}),
+      grok: {
+        ...DEFAULT_CONFIG.apis.grok,
+        model: grokModel,
+      },
     };
   }
 
   // Default language
   const defaultLanguage = process.env[ENV_VARS.DEFAULT_LANGUAGE];
-  if (defaultLanguage && (defaultLanguage === 'python' || defaultLanguage === 'typescript')) {
+  if (defaultLanguage && (defaultLanguage === 'python' || defaultLanguage === 'typescript' || defaultLanguage === 'fullstack')) {
     config.project = {
       ...DEFAULT_CONFIG.project,
       default_language: defaultLanguage,
@@ -126,7 +140,7 @@ function loadEnvConfig(): Partial<Config> {
 
   // Reviewer
   const reviewer = process.env[ENV_VARS.CONSENSUS_REVIEWER];
-  if (reviewer && (reviewer === 'openai' || reviewer === 'gemini')) {
+  if (reviewer && (reviewer === 'openai' || reviewer === 'gemini' || reviewer === 'grok')) {
     config.consensus = {
       ...DEFAULT_CONFIG.consensus,
       ...(config.consensus || {}),
@@ -136,7 +150,7 @@ function loadEnvConfig(): Partial<Config> {
 
   // Arbitrator
   const arbitrator = process.env[ENV_VARS.CONSENSUS_ARBITRATOR];
-  if (arbitrator && (arbitrator === 'openai' || arbitrator === 'gemini' || arbitrator === 'off')) {
+  if (arbitrator && (arbitrator === 'openai' || arbitrator === 'gemini' || arbitrator === 'grok' || arbitrator === 'off')) {
     config.consensus = {
       ...DEFAULT_CONFIG.consensus,
       ...(config.consensus || {}),

package/src/config/schema.ts

@@ -13,8 +13,8 @@ export const ConsensusSettingsSchema = z.object({
   max_disagreements: z.number().min(1).max(10).default(5),
   escalation_action: z.enum(['pause', 'continue', 'abort']).default('pause'),
   // Reviewer and arbitrator settings (persisted across sessions)
-  reviewer: z.enum(['openai', 'gemini']).default('openai'),
-  arbitrator: z.enum(['openai', 'gemini', 'off']).default('off'),
+  reviewer: z.enum(['openai', 'gemini', 'grok']).default('openai'),
+  arbitrator: z.enum(['openai', 'gemini', 'grok', 'off']).default('off'),
   enable_arbitration: z.boolean().default(false),
 });
 
@@ -39,6 +39,16 @@ export const ClaudeSettingsSchema = z.object({
   model: z.string().default('claude-sonnet-4-20250514'),
 });
 
+/**
+ * Grok API settings schema
+ */
+export const GrokSettingsSchema = z.object({
+  model: z.string().default('grok-3'),
+  temperature: z.number().min(0).max(2).default(0.3),
+  max_tokens: z.number().min(100).max(32000).default(4096),
+  api_url: z.string().default('https://api.x.ai/v1'),
+});
+
 /**
  * API configuration schema
  */
@@ -52,6 +62,12 @@ export const APISettingsSchema = z.object({
   claude: ClaudeSettingsSchema.default({
     model: 'claude-sonnet-4-20250514',
   }),
+  grok: GrokSettingsSchema.default({
+    model: 'grok-3',
+    temperature: 0.3,
+    max_tokens: 4096,
+    api_url: 'https://api.x.ai/v1',
+  }),
 });
 
 /**
@@ -76,7 +92,7 @@ export const TypeScriptSettingsSchema = z.object({
  * Project defaults schema
  */
 export const ProjectSettingsSchema = z.object({
-  default_language: z.enum(['python', 'typescript']).default('python'),
+  default_language: z.enum(['python', 'typescript', 'fullstack']).default('python'),
   python: PythonSettingsSchema.default({
     package_manager: 'pip',
     test_framework: 'pytest',
@@ -130,6 +146,12 @@ export const ConfigSchema = z.object({
     claude: {
       model: 'claude-sonnet-4-20250514',
     },
+    grok: {
+      model: 'grok-3',
+      temperature: 0.3,
+      max_tokens: 4096,
+      api_url: 'https://api.x.ai/v1',
+    },
   }),
   project: ProjectSettingsSchema.default({
     default_language: 'python',

package/src/generators/fullstack.ts

@@ -0,0 +1,551 @@
+/**
+ * Fullstack project generator
+ * Orchestrates Python and TypeScript generators for monorepo structure
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import type { ProjectSpec } from '../types/project.js';
+import type { GenerationResult } from './python.js';
+import {
+  generateWorkspaceJson,
+  generateRootDockerCompose,
+  generateRootReadme,
+  generateRootGitignore,
+  generateFrontendReadme,
+  generateBackendReadme,
+  generateUiSpec,
+  generateViteConfigReact,
+  generateTailwindConfig,
+  generatePostcssConfig,
+  generateMainCss,
+  generateAppTsx,
+  generateMainTsx,
+  generateIndexHtml,
+  generateFrontendPackageJson,
+  generateFrontendTsconfig,
+  generateFrontendTsconfigNode,
+  generateFrontendDockerfile,
+  generateNginxConfig,
+  generateFrontendTest,
+  generateVitestSetup,
+  generateFrontendVitestConfig,
+  generateFastAPIMain,
+  generateBackendDockerfile,
+  generateFastAPIRequirements,
+} from './templates/fullstack.js';
+
+/**
+ * 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');
+}
+
+/**
+ * Convert project name to Python package name
+ */
+function toPythonPackageName(name: string): string {
+  return name.toLowerCase().replace(/-/g, '_').replace(/[^a-z0-9_]/g, '');
+}
+
+/**
+ * Generate a complete fullstack project (React frontend + FastAPI backend)
+ *
+ * @param spec - Project specification
+ * @param outputDir - Output directory
+ * @returns Generation result
+ */
+export async function generateFullstackProject(
+  spec: ProjectSpec,
+  outputDir: string
+): Promise<GenerationResult> {
+  const projectName = spec.name || 'my-project';
+  const projectDir = path.join(outputDir, projectName);
+  const packageName = toPythonPackageName(projectName);
+  const filesCreated: string[] = [];
+
+  try {
+    // Create root directory structure
+    await ensureDir(projectDir);
+    await ensureDir(path.join(projectDir, 'apps'));
+    await ensureDir(path.join(projectDir, 'apps', 'frontend'));
+    await ensureDir(path.join(projectDir, 'apps', 'frontend', 'src'));
+    await ensureDir(path.join(projectDir, 'apps', 'frontend', 'tests'));
+    await ensureDir(path.join(projectDir, 'apps', 'frontend', 'public'));
+    await ensureDir(path.join(projectDir, 'apps', 'backend'));
+    await ensureDir(path.join(projectDir, 'apps', 'backend', 'src', packageName));
+    await ensureDir(path.join(projectDir, 'apps', 'backend', 'tests'));
+    await ensureDir(path.join(projectDir, 'packages', 'contracts'));
+    await ensureDir(path.join(projectDir, 'infra', 'docker'));
+    await ensureDir(path.join(projectDir, 'docs'));
+    await ensureDir(path.join(projectDir, '.popeye'));
+
+    // Generate root-level files
+    const rootFiles: Array<{ path: string; content: string }> = [
+      // Root config
+      {
+        path: path.join(projectDir, '.popeye', 'workspace.json'),
+        content: generateWorkspaceJson(projectName),
+      },
+      {
+        path: path.join(projectDir, '.popeye', 'ui-spec.json'),
+        content: generateUiSpec(projectName),
+      },
+      // Docker
+      {
+        path: path.join(projectDir, 'infra', 'docker', 'docker-compose.yml'),
+        content: generateRootDockerCompose(projectName),
+      },
+      {
+        path: path.join(projectDir, 'docker-compose.yml'),
+        content: generateRootDockerCompose(projectName),
+      },
+      // Documentation
+      {
+        path: path.join(projectDir, 'README.md'),
+        content: generateRootReadme(projectName, spec.idea),
+      },
+      {
+        path: path.join(projectDir, '.gitignore'),
+        content: generateRootGitignore(),
+      },
+      // Docs placeholders
+      {
+        path: path.join(projectDir, 'docs', 'PLAN.md'),
+        content: `# ${projectName} - Development Plan\n\nGenerated by Popeye CLI.\n`,
+      },
+      {
+        path: path.join(projectDir, 'docs', 'WORKFLOW_LOG.md'),
+        content: `# ${projectName} - Workflow Log\n\nGenerated by Popeye CLI.\n`,
+      },
+      // Packages placeholder
+      {
+        path: path.join(projectDir, 'packages', 'contracts', '.gitkeep'),
+        content: '',
+      },
+    ];
+
+    // Write root files
+    for (const file of rootFiles) {
+      await writeFile(file.path, file.content);
+      filesCreated.push(file.path);
+    }
+
+    // Generate frontend (React + Vite + Tailwind)
+    const frontendDir = path.join(projectDir, 'apps', 'frontend');
+    const frontendFiles: Array<{ path: string; content: string }> = [
+      // Config files
+      {
+        path: path.join(frontendDir, 'package.json'),
+        content: generateFrontendPackageJson(projectName),
+      },
+      {
+        path: path.join(frontendDir, 'tsconfig.json'),
+        content: generateFrontendTsconfig(),
+      },
+      {
+        path: path.join(frontendDir, 'tsconfig.node.json'),
+        content: generateFrontendTsconfigNode(),
+      },
+      {
+        path: path.join(frontendDir, 'vite.config.ts'),
+        content: generateViteConfigReact(),
+      },
+      {
+        path: path.join(frontendDir, 'vitest.config.ts'),
+        content: generateFrontendVitestConfig(),
+      },
+      {
+        path: path.join(frontendDir, 'tailwind.config.ts'),
+        content: generateTailwindConfig(),
+      },
+      {
+        path: path.join(frontendDir, 'postcss.config.js'),
+        content: generatePostcssConfig(),
+      },
+      // Entry files
+      {
+        path: path.join(frontendDir, 'index.html'),
+        content: generateIndexHtml(projectName),
+      },
+      {
+        path: path.join(frontendDir, 'src', 'main.tsx'),
+        content: generateMainTsx(),
+      },
+      {
+        path: path.join(frontendDir, 'src', 'App.tsx'),
+        content: generateAppTsx(projectName),
+      },
+      {
+        path: path.join(frontendDir, 'src', 'index.css'),
+        content: generateMainCss(),
+      },
+      {
+        path: path.join(frontendDir, 'src', 'vite-env.d.ts'),
+        content: '/// <reference types="vite/client" />\n',
+      },
+      // Test files
+      {
+        path: path.join(frontendDir, 'tests', 'setup.ts'),
+        content: generateVitestSetup(),
+      },
+      {
+        path: path.join(frontendDir, 'tests', 'App.test.tsx'),
+        content: generateFrontendTest(projectName),
+      },
+      // Docker
+      {
+        path: path.join(frontendDir, 'Dockerfile'),
+        content: generateFrontendDockerfile(),
+      },
+      {
+        path: path.join(frontendDir, 'nginx.conf'),
+        content: generateNginxConfig(),
+      },
+      // Documentation
+      {
+        path: path.join(frontendDir, 'README.md'),
+        content: generateFrontendReadme(projectName),
+      },
+      // Environment
+      {
+        path: path.join(frontendDir, '.env.example'),
+        content: 'VITE_API_URL=http://localhost:8000\n',
+      },
+      {
+        path: path.join(frontendDir, '.gitignore'),
+        content: 'node_modules/\ndist/\n.env\n.env.local\ncoverage/\n',
+      },
+    ];
+
+    // Write frontend files
+    for (const file of frontendFiles) {
+      await writeFile(file.path, file.content);
+      filesCreated.push(file.path);
+    }
+
+    // Generate backend (FastAPI)
+    const backendDir = path.join(projectDir, 'apps', 'backend');
+    const backendFiles: Array<{ path: string; content: string }> = [
+      // Config files
+      {
+        path: path.join(backendDir, 'pyproject.toml'),
+        content: generatePyprojectToml(projectName, packageName),
+      },
+      {
+        path: path.join(backendDir, 'requirements.txt'),
+        content: generateFastAPIRequirements(),
+      },
+      // Source files
+      {
+        path: path.join(backendDir, 'src', '__init__.py'),
+        content: '# Source root\n',
+      },
+      {
+        path: path.join(backendDir, 'src', packageName, '__init__.py'),
+        content: `"""${projectName} backend package."""\n\n__version__ = "1.0.0"\n`,
+      },
+      {
+        path: path.join(backendDir, 'src', packageName, 'main.py'),
+        content: generateFastAPIMain(projectName),
+      },
+      // Test files
+      {
+        path: path.join(backendDir, 'tests', '__init__.py'),
+        content: '# Tests package\n',
+      },
+      {
+        path: path.join(backendDir, 'tests', 'conftest.py'),
+        content: generateConftest(),
+      },
+      {
+        path: path.join(backendDir, 'tests', 'test_main.py'),
+        content: generateBackendTest(projectName, packageName),
+      },
+      // Docker
+      {
+        path: path.join(backendDir, 'Dockerfile'),
+        content: generateBackendDockerfile(projectName),
+      },
+      // Documentation
+      {
+        path: path.join(backendDir, 'README.md'),
+        content: generateBackendReadme(projectName),
+      },
+      // Environment
+      {
+        path: path.join(backendDir, '.env.example'),
+        content: 'DEBUG=true\nDATABASE_URL=sqlite:///./data/app.db\n',
+      },
+      {
+        path: path.join(backendDir, '.gitignore'),
+        content: '__pycache__/\n*.py[cod]\nvenv/\n.venv/\n.env\n.coverage\nhtmlcov/\n.pytest_cache/\ndata/\n',
+      },
+      // Makefile
+      {
+        path: path.join(backendDir, 'Makefile'),
+        content: generateBackendMakefile(packageName),
+      },
+    ];
+
+    // Write backend files
+    for (const file of backendFiles) {
+      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',
+    };
+  }
+}
+
+/**
+ * Generate pyproject.toml for FastAPI backend
+ */
+function generatePyprojectToml(projectName: string, _packageName: string): string {
+  return `[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "${projectName}-backend"
+version = "1.0.0"
+description = "Backend API for ${projectName}"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+dependencies = [
+    "fastapi>=0.109.0",
+    "uvicorn[standard]>=0.27.0",
+    "pydantic>=2.5.0",
+    "pydantic-settings>=2.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.23.0",
+    "httpx>=0.26.0",
+    "ruff>=0.1.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W"]
+`;
+}
+
+/**
+ * Generate conftest.py for backend tests
+ */
+function generateConftest(): string {
+  return `"""
+Test configuration and fixtures.
+"""
+
+import pytest
+from httpx import AsyncClient
+from httpx import ASGITransport
+
+
+@pytest.fixture
+def anyio_backend():
+    """Use asyncio backend for pytest-anyio."""
+    return "asyncio"
+
+
+@pytest.fixture
+async def client():
+    """Create async test client."""
+    from src.backend.main import app
+
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        yield client
+`;
+}
+
+/**
+ * Generate test file for backend
+ */
+function generateBackendTest(projectName: string, _packageName: string): string {
+  return `"""
+Tests for ${projectName} backend API.
+"""
+
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.anyio
+async def test_health_check(client: AsyncClient):
+    """Test health check endpoint."""
+    response = await client.get("/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "healthy"
+
+
+@pytest.mark.anyio
+async def test_root(client: AsyncClient):
+    """Test root endpoint."""
+    response = await client.get("/")
+    assert response.status_code == 200
+    data = response.json()
+    assert "message" in data
+    assert "docs" in data
+`;
+}
+
+/**
+ * Generate Makefile for backend
+ */
+function generateBackendMakefile(packageName: string): string {
+  return `.PHONY: dev test lint format clean install
+
+install:
+\tpip install -e ".[dev]"
+
+dev:
+\tuvicorn src.${packageName}.main:app --reload --port 8000
+
+test:
+\tpytest -v
+
+test-cov:
+\tpytest --cov=src/${packageName} --cov-report=html
+
+lint:
+\truff check src/ tests/
+
+format:
+\truff format src/ tests/
+
+clean:
+\trm -rf __pycache__ .pytest_cache .coverage htmlcov .ruff_cache
+\tfind . -type d -name "__pycache__" -exec rm -rf {} +
+`;
+}
+
+/**
+ * Get the list of files that would be generated for a fullstack project
+ *
+ * @param projectName - Project name
+ * @returns List of relative file paths
+ */
+export function getFullstackProjectFiles(projectName: string): string[] {
+  const packageName = toPythonPackageName(projectName);
+
+  return [
+    // Root
+    '.popeye/workspace.json',
+    '.popeye/ui-spec.json',
+    'infra/docker/docker-compose.yml',
+    'docker-compose.yml',
+    'README.md',
+    '.gitignore',
+    'docs/PLAN.md',
+    'docs/WORKFLOW_LOG.md',
+    'packages/contracts/.gitkeep',
+    // Frontend
+    'apps/frontend/package.json',
+    'apps/frontend/tsconfig.json',
+    'apps/frontend/tsconfig.node.json',
+    'apps/frontend/vite.config.ts',
+    'apps/frontend/vitest.config.ts',
+    'apps/frontend/tailwind.config.ts',
+    'apps/frontend/postcss.config.js',
+    'apps/frontend/index.html',
+    'apps/frontend/src/main.tsx',
+    'apps/frontend/src/App.tsx',
+    'apps/frontend/src/index.css',
+    'apps/frontend/src/vite-env.d.ts',
+    'apps/frontend/tests/setup.ts',
+    'apps/frontend/tests/App.test.tsx',
+    'apps/frontend/Dockerfile',
+    'apps/frontend/nginx.conf',
+    'apps/frontend/README.md',
+    'apps/frontend/.env.example',
+    'apps/frontend/.gitignore',
+    // Backend
+    'apps/backend/pyproject.toml',
+    'apps/backend/requirements.txt',
+    'apps/backend/src/__init__.py',
+    `apps/backend/src/${packageName}/__init__.py`,
+    `apps/backend/src/${packageName}/main.py`,
+    'apps/backend/tests/__init__.py',
+    'apps/backend/tests/conftest.py',
+    'apps/backend/tests/test_main.py',
+    'apps/backend/Dockerfile',
+    'apps/backend/README.md',
+    'apps/backend/.env.example',
+    'apps/backend/.gitignore',
+    'apps/backend/Makefile',
+  ];
+}
+
+/**
+ * Validate a fullstack project structure
+ *
+ * @param projectDir - Project directory
+ * @returns Validation result
+ */
+export async function validateFullstackProject(projectDir: string): Promise<{
+  valid: boolean;
+  missingFiles: string[];
+}> {
+  const missingFiles: string[] = [];
+
+  const requiredPaths = [
+    'apps/frontend/package.json',
+    'apps/frontend/src',
+    'apps/backend/pyproject.toml',
+    'apps/backend/src',
+    '.popeye/workspace.json',
+    'docker-compose.yml',
+    'README.md',
+  ];
+
+  for (const file of requiredPaths) {
+    const filePath = path.join(projectDir, file);
+    try {
+      await fs.access(filePath);
+    } catch {
+      missingFiles.push(file);
+    }
+  }
+
+  return {
+    valid: missingFiles.length === 0,
+    missingFiles,
+  };
+}