popeye-cli 1.0.0

package/src/generators/index.ts

@@ -0,0 +1,251 @@
+/**
+ * Project generators module
+ * Provides unified API for generating Python and TypeScript projects
+ */
+
+import type { ProjectSpec, OutputLanguage } from '../types/project.js';
+import {
+  generatePythonProject,
+  validatePythonProject,
+  addPythonModule,
+  getPythonProjectFiles,
+  type GenerationResult,
+} from './python.js';
+import {
+  generateTypeScriptProject,
+  validateTypeScriptProject,
+  addTypeScriptModule,
+  getTypeScriptProjectFiles,
+} from './typescript.js';
+
+// Re-export (explicitly to avoid name conflicts)
+export {
+  generatePythonProject,
+  validatePythonProject,
+  addPythonModule,
+  getPythonProjectFiles,
+  type GenerationResult,
+} from './python.js';
+export {
+  generateTypeScriptProject,
+  validateTypeScriptProject,
+  addTypeScriptModule,
+  getTypeScriptProjectFiles,
+  addDependency,
+  updateScripts,
+} from './typescript.js';
+export * from './templates/index.js';
+
+/**
+ * Generate a project based on the specification
+ *
+ * @param spec - Project specification
+ * @param outputDir - Output directory
+ * @returns Generation result
+ */
+export async function generateProject(
+  spec: ProjectSpec,
+  outputDir: string
+): Promise<GenerationResult> {
+  switch (spec.language) {
+    case 'python':
+      return generatePythonProject(spec, outputDir);
+    case 'typescript':
+      return generateTypeScriptProject(spec, outputDir);
+    default:
+      return {
+        success: false,
+        projectDir: outputDir,
+        filesCreated: [],
+        error: `Unsupported language: ${spec.language}`,
+      };
+  }
+}
+
+/**
+ * Validate a project structure
+ *
+ * @param projectDir - Project directory
+ * @param language - Project language
+ * @returns Validation result
+ */
+export async function validateProject(
+  projectDir: string,
+  language: OutputLanguage
+): Promise<{
+  valid: boolean;
+  missingFiles: string[];
+}> {
+  switch (language) {
+    case 'python':
+      return validatePythonProject(projectDir);
+    case 'typescript':
+      return validateTypeScriptProject(projectDir);
+    default:
+      return {
+        valid: false,
+        missingFiles: ['Unknown language'],
+      };
+  }
+}
+
+/**
+ * Add a module to an existing project
+ *
+ * @param projectDir - Project directory
+ * @param moduleName - Module name
+ * @param language - Project language
+ * @returns Files created
+ */
+export async function addModule(
+  projectDir: string,
+  moduleName: string,
+  language: OutputLanguage
+): Promise<string[]> {
+  switch (language) {
+    case 'python':
+      return addPythonModule(projectDir, moduleName);
+    case 'typescript':
+      return addTypeScriptModule(projectDir, moduleName);
+    default:
+      throw new Error(`Unsupported language: ${language}`);
+  }
+}
+
+/**
+ * Get the list of files that would be generated for a project
+ *
+ * @param projectName - Project name
+ * @param language - Project language
+ * @returns List of relative file paths
+ */
+export function getProjectFiles(projectName: string, language: OutputLanguage): string[] {
+  switch (language) {
+    case 'python':
+      return getPythonProjectFiles(projectName);
+    case 'typescript':
+      return getTypeScriptProjectFiles(projectName);
+    default:
+      return [];
+  }
+}
+
+/**
+ * Get the default test command for a language
+ *
+ * @param language - Project language
+ * @returns Test command
+ */
+export function getTestCommand(language: OutputLanguage): string {
+  switch (language) {
+    case 'python':
+      return 'python -m pytest tests/ -v';
+    case 'typescript':
+      return 'npm test';
+    default:
+      return 'echo "No test command configured"';
+  }
+}
+
+/**
+ * Get the default build command for a language
+ *
+ * @param language - Project language
+ * @returns Build command
+ */
+export function getBuildCommand(language: OutputLanguage): string {
+  switch (language) {
+    case 'python':
+      return 'python -m pip install -e .';
+    case 'typescript':
+      return 'npm run build';
+    default:
+      return 'echo "No build command configured"';
+  }
+}
+
+/**
+ * Get the default lint command for a language
+ *
+ * @param language - Project language
+ * @returns Lint command
+ */
+export function getLintCommand(language: OutputLanguage): string {
+  switch (language) {
+    case 'python':
+      return 'ruff check src/ tests/';
+    case 'typescript':
+      return 'npm run lint';
+    default:
+      return 'echo "No lint command configured"';
+  }
+}
+
+/**
+ * Get the file extension for a language
+ *
+ * @param language - Project language
+ * @returns File extension (without dot)
+ */
+export function getFileExtension(language: OutputLanguage): string {
+  switch (language) {
+    case 'python':
+      return 'py';
+    case 'typescript':
+      return 'ts';
+    default:
+      return 'txt';
+  }
+}
+
+/**
+ * Get the source directory name for a language
+ *
+ * @param language - Project language
+ * @returns Source directory name
+ */
+export function getSourceDir(_language: OutputLanguage): string {
+  return 'src';
+}
+
+/**
+ * Get the test directory name for a language
+ *
+ * @param language - Project language
+ * @returns Test directory name
+ */
+export function getTestDir(_language: OutputLanguage): string {
+  return 'tests';
+}
+
+/**
+ * Check if a project directory already exists and has content
+ *
+ * @param projectDir - Project directory
+ * @returns True if directory exists and has content
+ */
+export async function projectDirExists(projectDir: string): Promise<boolean> {
+  const { promises: fs } = await import('node:fs');
+
+  try {
+    const files = await fs.readdir(projectDir);
+    return files.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Clean up a failed project generation
+ *
+ * @param projectDir - Project directory
+ */
+export async function cleanupProject(projectDir: string): Promise<void> {
+  const { promises: fs } = await import('node:fs');
+
+  try {
+    await fs.rm(projectDir, { recursive: true, force: true });
+  } catch {
+    // Ignore errors
+  }
+}

package/src/generators/python.ts

@@ -0,0 +1,318 @@
+/**
+ * Python project generator
+ * Creates complete Python project scaffolding
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import type { ProjectSpec } from '../types/project.js';
+import {
+  generatePyprojectToml,
+  generateRequirementsTxt,
+  generateMainInit,
+  generateMainPy,
+  generateConftest,
+  generateTestMain,
+  generateDockerfile,
+  generateDockerCompose,
+  generateGitignore,
+  generateEnvExample,
+  generateReadme,
+  generateMakefile,
+} from './templates/python.js';
+
+/**
+ * Project generation result
+ */
+export interface GenerationResult {
+  success: boolean;
+  projectDir: string;
+  filesCreated: string[];
+  error?: string;
+}
+
+/**
+ * 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 Python project
+ *
+ * @param spec - Project specification
+ * @param outputDir - Output directory
+ * @returns Generation result
+ */
+export async function generatePythonProject(
+  spec: ProjectSpec,
+  outputDir: string
+): Promise<GenerationResult> {
+  const projectName = spec.name || 'my-project';
+  const packageName = toPythonPackageName(projectName);
+  const projectDir = path.join(outputDir, projectName);
+  const filesCreated: string[] = [];
+
+  try {
+    // Create project directory structure
+    await ensureDir(projectDir);
+    await ensureDir(path.join(projectDir, 'src', packageName));
+    await ensureDir(path.join(projectDir, 'tests'));
+    await ensureDir(path.join(projectDir, 'data'));
+
+    // Generate and write files
+    const files: Array<{ path: string; content: string }> = [
+      // Root files
+      {
+        path: path.join(projectDir, 'pyproject.toml'),
+        content: generatePyprojectToml(projectName),
+      },
+      {
+        path: path.join(projectDir, 'requirements.txt'),
+        content: generateRequirementsTxt(),
+      },
+      {
+        path: path.join(projectDir, '.gitignore'),
+        content: generateGitignore(),
+      },
+      {
+        path: path.join(projectDir, '.env.example'),
+        content: generateEnvExample(),
+      },
+      {
+        path: path.join(projectDir, 'README.md'),
+        content: generateReadme(projectName, spec.idea),
+      },
+      {
+        path: path.join(projectDir, 'Makefile'),
+        content: generateMakefile(projectName),
+      },
+      {
+        path: path.join(projectDir, 'Dockerfile'),
+        content: generateDockerfile(projectName),
+      },
+      {
+        path: path.join(projectDir, 'docker-compose.yml'),
+        content: generateDockerCompose(projectName),
+      },
+
+      // Source files
+      {
+        path: path.join(projectDir, 'src', packageName, '__init__.py'),
+        content: generateMainInit(projectName),
+      },
+      {
+        path: path.join(projectDir, 'src', packageName, 'main.py'),
+        content: generateMainPy(projectName),
+      },
+      {
+        path: path.join(projectDir, 'src', '__init__.py'),
+        content: '# Source root\n',
+      },
+
+      // Test files
+      {
+        path: path.join(projectDir, 'tests', '__init__.py'),
+        content: '# Tests package\n',
+      },
+      {
+        path: path.join(projectDir, 'tests', 'conftest.py'),
+        content: generateConftest(),
+      },
+      {
+        path: path.join(projectDir, 'tests', 'test_main.py'),
+        content: generateTestMain(projectName),
+      },
+
+      // Data placeholder
+      {
+        path: path.join(projectDir, 'data', '.gitkeep'),
+        content: '',
+      },
+    ];
+
+    // 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
+ *
+ * @param projectName - Project name
+ * @returns List of relative file paths
+ */
+export function getPythonProjectFiles(projectName: string): string[] {
+  const packageName = toPythonPackageName(projectName);
+
+  return [
+    'pyproject.toml',
+    'requirements.txt',
+    '.gitignore',
+    '.env.example',
+    'README.md',
+    'Makefile',
+    'Dockerfile',
+    'docker-compose.yml',
+    `src/${packageName}/__init__.py`,
+    `src/${packageName}/main.py`,
+    'src/__init__.py',
+    'tests/__init__.py',
+    'tests/conftest.py',
+    'tests/test_main.py',
+    'data/.gitkeep',
+  ];
+}
+
+/**
+ * Validate a Python project structure
+ *
+ * @param projectDir - Project directory
+ * @returns Validation result
+ */
+export async function validatePythonProject(projectDir: string): Promise<{
+  valid: boolean;
+  missingFiles: string[];
+}> {
+  const missingFiles: string[] = [];
+
+  const requiredFiles = [
+    'pyproject.toml',
+    'requirements.txt',
+    'README.md',
+    'src',
+    'tests',
+  ];
+
+  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,
+  };
+}
+
+/**
+ * Add a new Python module to an existing project
+ *
+ * @param projectDir - Project directory
+ * @param moduleName - Module name
+ * @returns Files created
+ */
+export async function addPythonModule(
+  projectDir: string,
+  moduleName: string
+): Promise<string[]> {
+  const packageName = toPythonPackageName(moduleName);
+  const filesCreated: string[] = [];
+
+  // Find the src directory
+  const srcDir = path.join(projectDir, 'src');
+  const dirs = await fs.readdir(srcDir);
+  const packageDir = dirs.find((d) => !d.startsWith('.') && d !== '__init__.py');
+
+  if (!packageDir) {
+    throw new Error('Could not find package directory in src/');
+  }
+
+  const moduleDir = path.join(srcDir, packageDir, packageName);
+  await ensureDir(moduleDir);
+
+  // Create module files
+  const initContent = `"""
+${moduleName} module.
+"""
+`;
+  await writeFile(path.join(moduleDir, '__init__.py'), initContent);
+  filesCreated.push(path.join(moduleDir, '__init__.py'));
+
+  const moduleContent = `"""
+${moduleName} implementation.
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ${moduleName.charAt(0).toUpperCase() + moduleName.slice(1).replace(/-/g, '')}:
+    """
+    ${moduleName} class.
+    """
+
+    def __init__(self) -> None:
+        """Initialize ${moduleName}."""
+        logger.info(f"Initializing {self.__class__.__name__}")
+
+    def run(self) -> None:
+        """
+        Run the ${moduleName} logic.
+
+        This method should be implemented with the actual functionality.
+        """
+        raise NotImplementedError("Implement this method")
+`;
+  await writeFile(path.join(moduleDir, 'module.py'), moduleContent);
+  filesCreated.push(path.join(moduleDir, 'module.py'));
+
+  // Create test file
+  const testDir = path.join(projectDir, 'tests');
+  const testContent = `"""
+Tests for ${moduleName} module.
+"""
+
+import pytest
+
+# from src.${packageDir}.${packageName}.module import ${moduleName.charAt(0).toUpperCase() + moduleName.slice(1).replace(/-/g, '')}
+
+
+class Test${moduleName.charAt(0).toUpperCase() + moduleName.slice(1).replace(/-/g, '')}:
+    """Test cases for ${moduleName}."""
+
+    def test_placeholder(self) -> None:
+        """Placeholder test."""
+        assert True
+`;
+  await writeFile(path.join(testDir, `test_${packageName}.py`), testContent);
+  filesCreated.push(path.join(testDir, `test_${packageName}.py`));
+
+  return filesCreated;
+}

package/src/generators/templates/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Template module exports
+ */
+
+export * as pythonTemplates from './python.js';
+export * as typescriptTemplates from './typescript.js';