atena-cli 0.1.0

package/dist/core/orchestrator.js

@@ -0,0 +1,801 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export class TaskOrchestrator {
+    agent;
+    tasksDir;
+    currentTask = null;
+    constructor(agent, cwd) {
+        this.agent = agent;
+        this.tasksDir = path.join(cwd, '.eden', 'tasks');
+    }
+    async initialize() {
+        await fs.mkdir(this.tasksDir, { recursive: true });
+    }
+    async planTask(prompt) {
+        const planningPrompt = `Analiza este prompt y divídelo en subtareas atómicas ejecutables:
+
+PROMPT ORIGINAL:
+${prompt}
+
+INSTRUCCIONES:
+1. Divide el trabajo en subtareas pequeñas y específicas (máximo 5-7 subtareas)
+2. Cada subtarea debe ser ejecutable en UN SOLO turno de agente
+3. Define dependencias claras (qué subtareas deben ir antes)
+4. Prioriza el orden lógico de ejecución
+
+FORMATO DE RESPUESTA (JSON):
+{
+  "subtasks": [
+    {
+      "id": "subtask-1",
+      "description": "Descripción breve",
+      "prompt": "Prompt específico para el agente",
+      "dependencies": []
+    },
+    {
+      "id": "subtask-2", 
+      "description": "Descripción breve",
+      "prompt": "Prompt específico para el agente",
+      "dependencies": ["subtask-1"]
+    }
+  ]
+}
+
+Responde SOLO con el JSON, sin explicaciones adicionales.`;
+        // Simular llamada al agente para planificación
+        const taskId = `task-${Date.now()}`;
+        // Por ahora, usar planificación basada en reglas simples
+        const subtasks = this.generateSubtasks(prompt);
+        const task = {
+            id: taskId,
+            originalPrompt: prompt,
+            subtasks,
+            status: 'planning',
+            currentSubtaskIndex: 0,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        this.currentTask = task;
+        await this.saveTask(task);
+        return task;
+    }
+    generateSubtasks(prompt) {
+        // Detectar tipo de proyecto y generar subtareas apropiadas
+        const lowerPrompt = prompt.toLowerCase();
+        if (lowerPrompt.includes('portfolio') || lowerPrompt.includes('landing')) {
+            return this.generatePortfolioSubtasks(prompt);
+        }
+        if (lowerPrompt.includes('saas') || lowerPrompt.includes('dashboard')) {
+            return this.generateSaaSSubtasks(prompt);
+        }
+        if (lowerPrompt.includes('api') || lowerPrompt.includes('backend') || lowerPrompt.includes('rest')) {
+            return this.generateBackendSubtasks(prompt);
+        }
+        if (lowerPrompt.includes('mobile') || lowerPrompt.includes('app') || lowerPrompt.includes('react native')) {
+            return this.generateMobileSubtasks(prompt);
+        }
+        if (lowerPrompt.includes('ecommerce') || lowerPrompt.includes('e-commerce') || lowerPrompt.includes('shop') || lowerPrompt.includes('store')) {
+            return this.generateEcommerceSubtasks(prompt);
+        }
+        if (lowerPrompt.includes('documentation') || lowerPrompt.includes('docs')) {
+            return this.generateDocsSubtasks(prompt);
+        }
+        // Subtareas genéricas
+        return [
+            {
+                id: 'subtask-1',
+                description: 'Analizar requerimientos',
+                prompt: `Analiza este prompt y crea un plan detallado: ${prompt}`,
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'subtask-2',
+                description: 'Implementar solución',
+                prompt: prompt,
+                status: 'pending',
+                dependencies: ['subtask-1'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'subtask-3',
+                description: 'Verificar resultado',
+                prompt: 'Verifica que todos los requerimientos se cumplieron',
+                status: 'pending',
+                dependencies: ['subtask-2'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    generatePortfolioSubtasks(prompt) {
+        return [
+            {
+                id: 'setup',
+                description: 'Inicializar proyecto Next.js + shadcn/ui',
+                prompt: 'Inicializa un proyecto Next.js con shadcn/ui. Ejecuta: echo "my-app" | npx shadcn@latest init --yes --template next --base-color neutral',
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'styles',
+                description: 'Configurar estilos globales minimalistas',
+                prompt: `Edita app/globals.css para aplicar estética minimalista Apple/Linear:
+- bg: #fafafa
+- texto: #171717  
+- border-radius: 0.75rem
+- Sin gradientes complejos
+- Scrollbar minimal`,
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'layout',
+                description: 'Crear layout.tsx con tema claro',
+                prompt: 'Edita app/layout.tsx para forzar tema claro y usar Inter como font',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'navbar',
+                description: 'Crear componente Navbar',
+                prompt: 'Crea components/navbar.tsx: Navbar fijo, fondo translúcido, links de navegación, sin theme toggle. Estilo minimalista.',
+                status: 'pending',
+                dependencies: ['styles'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'hero',
+                description: 'Crear HeroSection',
+                prompt: 'Crea components/hero-section.tsx: Headline grande, subtítulo, 2 CTAs redondeados, datos de contacto. Estilo minimalista Apple.',
+                status: 'pending',
+                dependencies: ['navbar'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'features',
+                description: 'Crear FeaturesSection',
+                prompt: 'Crea components/features-section.tsx: 3 cards con iconos (Code, Palette, Rocket), título, descripción. Cards con bg-white, border, shadow-sm.',
+                status: 'pending',
+                dependencies: ['hero'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'about',
+                description: 'Crear AboutPreview',
+                prompt: 'Crea components/about-preview.tsx: Sección "Sobre mí" con espacio para foto, bio breve, skills. Diseño limpio en 2 columnas.',
+                status: 'pending',
+                dependencies: ['features'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'projects',
+                description: 'Crear ProjectsSection',
+                prompt: 'Crea components/projects-section.tsx: Grid de 3 proyectos con imagen, título, descripción corta, tags, link. Hover suave.',
+                status: 'pending',
+                dependencies: ['about'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'contact',
+                description: 'Crear ContactSection',
+                prompt: 'Crea components/contact-section.tsx: Formulario simple (nombre, email, mensaje), botón rounded-full bg-primary. Sin funcionalidad real aún.',
+                status: 'pending',
+                dependencies: ['projects'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'footer',
+                description: 'Crear Footer',
+                prompt: 'Crea components/footer.tsx: Copyright, links sociales (GitHub, LinkedIn, Twitter), email. Diseño minimal.',
+                status: 'pending',
+                dependencies: ['contact'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'page',
+                description: 'Actualizar page.tsx con todas las secciones',
+                prompt: 'Edita app/page.tsx para importar y renderizar todos los componentes: Navbar, HeroSection, FeaturesSection, AboutPreview, ProjectsSection, ContactSection, Footer.',
+                status: 'pending',
+                dependencies: ['footer'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'verify',
+                description: 'Verificar todos los componentes creados',
+                prompt: 'Lista los archivos en components/ y verifica que existan: navbar.tsx, hero-section.tsx, features-section.tsx, about-preview.tsx, projects-section.tsx, contact-section.tsx, footer.tsx. Reporta cuáles faltan.',
+                status: 'pending',
+                dependencies: ['page'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    generateBackendSubtasks(prompt) {
+        return [
+            {
+                id: 'setup',
+                description: 'Inicializar proyecto backend',
+                prompt: 'Inicializa proyecto Node.js/TypeScript con package.json, tsconfig.json',
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'structure',
+                description: 'Crear estructura de carpetas',
+                prompt: 'Crea estructura: src/{routes,controllers,models,middleware,utils}',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'server',
+                description: 'Crear servidor Express/Fastify',
+                prompt: 'Crea servidor principal con rutas básicas y middleware',
+                status: 'pending',
+                dependencies: ['structure'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'verify',
+                description: 'Verificar servidor funciona',
+                prompt: 'Verifica que el servidor inicia sin errores',
+                status: 'pending',
+                dependencies: ['server'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    generateSaaSSubtasks(prompt) {
+        return [
+            {
+                id: 'setup',
+                description: 'Inicializar proyecto Next.js con autenticación',
+                prompt: 'Inicializa proyecto Next.js con shadcn/ui, configura NextAuth.js con credentials provider',
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'database',
+                description: 'Configurar base de datos Prisma',
+                prompt: 'Configura Prisma ORM con SQLite/PostgreSQL, crea schema básico User, Account, Session',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'auth',
+                description: 'Implementar sistema de autenticación',
+                prompt: 'Crea: login page, register page, auth middleware, protección de rutas. Usa NextAuth.',
+                status: 'pending',
+                dependencies: ['database'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'dashboard',
+                description: 'Crear Dashboard principal',
+                prompt: 'Crea app/dashboard/page.tsx: Layout con sidebar, header con user menu, stats cards, gráficos simples.',
+                status: 'pending',
+                dependencies: ['auth'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'settings',
+                description: 'Crear página de configuración',
+                prompt: 'Crea app/settings/page.tsx: Formulario para editar perfil, cambiar contraseña, notificaciones.',
+                status: 'pending',
+                dependencies: ['dashboard'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'api',
+                description: 'Crear API routes básicas',
+                prompt: 'Crea app/api/user/route.ts, app/api/dashboard/route.ts: CRUD operations con autenticación.',
+                status: 'pending',
+                dependencies: ['database'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'verify',
+                description: 'Verificar funcionalidad completa',
+                prompt: 'Verifica que login, dashboard, settings y API funcionan. Lista los archivos creados.',
+                status: 'pending',
+                dependencies: ['settings', 'api'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    generateMobileSubtasks(prompt) {
+        return [
+            {
+                id: 'setup',
+                description: 'Inicializar proyecto React Native / Expo',
+                prompt: 'Inicializa proyecto Expo con TypeScript: npx create-expo-app -t expo-template-blank-typescript',
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'navigation',
+                description: 'Configurar navegación',
+                prompt: 'Instala y configura React Navigation: npm install @react-navigation/native @react-navigation/stack. Crea stack navigator.',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'screens',
+                description: 'Crear pantallas principales',
+                prompt: 'Crea screens/: HomeScreen, ProfileScreen, SettingsScreen. Cada una con componente básico y estilos.',
+                status: 'pending',
+                dependencies: ['navigation'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'components',
+                description: 'Crear componentes reutilizables',
+                prompt: 'Crea components/: Button, Card, Input, Header. Estilo consistente con tema de la app.',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'verify',
+                description: 'Verificar estructura del proyecto',
+                prompt: 'Lista todos los archivos creados en screens/ y components/. Verifica App.tsx configura navegación.',
+                status: 'pending',
+                dependencies: ['screens', 'components'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    generateEcommerceSubtasks(prompt) {
+        return [
+            {
+                id: 'setup',
+                description: 'Inicializar proyecto con Shopify/Snipcart o custom',
+                prompt: 'Inicializa Next.js proyecto e-commerce. Instala: shadcn/ui, stripe (payments), opcional: shopify-buy SDK.',
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'products',
+                description: 'Crear catálogo de productos',
+                prompt: 'Crea: app/products/page.tsx (grid), app/products/[id]/page.tsx (detalle). Componente ProductCard reutilizable.',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'cart',
+                description: 'Implementar carrito de compras',
+                prompt: 'Crea context CartContext.tsx, hook useCart(), componente CartSheet (slide-out). Funcionalidad: add, remove, update qty.',
+                status: 'pending',
+                dependencies: ['products'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'checkout',
+                description: 'Crear flujo de checkout',
+                prompt: 'Crea app/checkout/page.tsx: Formulario dirección, resumen orden, integración botón Stripe/Snipcart.',
+                status: 'pending',
+                dependencies: ['cart'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'verify',
+                description: 'Verificar flujo e-commerce completo',
+                prompt: 'Verifica: catálogo carga, productos navegables, carrito funciona, checkout tiene UI. Lista componentes creados.',
+                status: 'pending',
+                dependencies: ['checkout'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    generateDocsSubtasks(prompt) {
+        return [
+            {
+                id: 'setup',
+                description: 'Inicializar proyecto documentación',
+                prompt: 'Inicializa: npx create-nextra-docs-site@latest o configura Next.js con MDX. Tema: Docs/mintlify style.',
+                status: 'pending',
+                dependencies: [],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'structure',
+                description: 'Crear estructura de documentación',
+                prompt: 'Crea: pages/index.mdx (home), pages/getting-started.mdx, pages/api/*.mdx, pages/guides/*.mdx. Configura _meta.json.',
+                status: 'pending',
+                dependencies: ['setup'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+            {
+                id: 'content',
+                description: 'Generar contenido inicial',
+                prompt: 'Escribe contenido introductorio: qué es el proyecto, instalación, primeros pasos. Usa MDX con componentes.',
+                status: 'pending',
+                dependencies: ['structure'],
+                retryCount: 0,
+                maxRetries: 3,
+            },
+            {
+                id: 'verify',
+                description: 'Verificar documentación navegable',
+                prompt: 'Verifica que todas las páginas están en _meta.json, navegación funciona, no hay links rotos.',
+                status: 'pending',
+                dependencies: ['content'],
+                retryCount: 0,
+                maxRetries: 2,
+            },
+        ];
+    }
+    async executeNextSubtask() {
+        if (!this.currentTask) {
+            throw new Error('No task loaded');
+        }
+        const pendingSubtasks = this.currentTask.subtasks.filter(st => st.status === 'pending' &&
+            st.dependencies.every(dep => this.currentTask.subtasks.find(s => s.id === dep)?.status === 'completed'));
+        if (pendingSubtasks.length === 0) {
+            // Verificar si todas están completas
+            const allCompleted = this.currentTask.subtasks.every(st => st.status === 'completed');
+            if (allCompleted) {
+                this.currentTask.status = 'completed';
+                await this.saveTask(this.currentTask);
+            }
+            return false;
+        }
+        const subtask = pendingSubtasks[0];
+        subtask.status = 'in_progress';
+        this.currentTask.status = 'executing';
+        await this.saveTask(this.currentTask);
+        console.log(`\n🎯 Ejecutando: ${subtask.description}`);
+        try {
+            // Aquí se ejecutaría el agente con el prompt de la subtarea
+            // Por ahora, simulamos que lo procesamos
+            const success = await this.executeSubtaskWithAgent(subtask);
+            if (success) {
+                subtask.status = 'completed';
+                console.log(`✅ Completado: ${subtask.description}`);
+            }
+            else {
+                subtask.status = 'failed';
+                subtask.retryCount++;
+                if (subtask.retryCount < subtask.maxRetries) {
+                    console.log(`⚠️  Falló, reintentando (${subtask.retryCount}/${subtask.maxRetries})...`);
+                    subtask.status = 'pending';
+                }
+                else {
+                    console.log(`❌ Falló después de ${subtask.maxRetries} intentos`);
+                }
+            }
+        }
+        catch (error) {
+            subtask.status = 'failed';
+            subtask.error = String(error);
+            console.log(`❌ Error: ${error}`);
+        }
+        this.currentTask.updatedAt = new Date().toISOString();
+        await this.saveTask(this.currentTask);
+        return true;
+    }
+    async executeSubtaskWithAgent(subtask) {
+        try {
+            // Ejecutar la subtarea usando el agente
+            // Llamamos a runSingleTurn con el prompt de la subtarea
+            await this.agent.runSingleTurn(subtask.prompt);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error executing subtask ${subtask.id}:`, error);
+            return false;
+        }
+    }
+    async executeAll() {
+        if (!this.currentTask) {
+            throw new Error('No task loaded');
+        }
+        console.log(`\n🚀 Orquestador iniciado: ${this.currentTask.subtasks.length} subtareas`);
+        console.log(`📁 Task ID: ${this.currentTask.id}\n`);
+        let hasMore = true;
+        while (hasMore) {
+            hasMore = await this.executeNextSubtask();
+            // Pequeña pausa entre subtareas
+            if (hasMore) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+        const completed = this.currentTask.subtasks.filter(s => s.status === 'completed').length;
+        const failed = this.currentTask.subtasks.filter(s => s.status === 'failed').length;
+        console.log(`\n📊 Resumen:`);
+        console.log(`   ✅ Completadas: ${completed}/${this.currentTask.subtasks.length}`);
+        console.log(`   ❌ Fallidas: ${failed}/${this.currentTask.subtasks.length}`);
+        if (failed === 0) {
+            console.log(`\n🎉 ¡Tarea completada exitosamente!`);
+        }
+        else {
+            console.log(`\n⚠️  Tarea completada con ${failed} subtareas fallidas`);
+        }
+    }
+    /**
+     * Execute multiple subtasks in parallel when they have no dependencies
+     */
+    async executeParallel() {
+        if (!this.currentTask) {
+            throw new Error('No task loaded');
+        }
+        console.log(`\n🚀 Orquestador paralelo iniciado: ${this.currentTask.subtasks.length} subtareas`);
+        const pendingSubtasks = () => this.currentTask.subtasks.filter(st => st.status === 'pending' &&
+            st.dependencies.every(dep => this.currentTask.subtasks.find(s => s.id === dep)?.status === 'completed'));
+        let batch = pendingSubtasks();
+        while (batch.length > 0) {
+            console.log(`\n📦 Ejecutando batch de ${batch.length} subtareas en paralelo...`);
+            // Execute all pending subtasks in parallel
+            const promises = batch.map(async (subtask) => {
+                subtask.status = 'in_progress';
+                await this.saveTask(this.currentTask);
+                console.log(`  🎯 ${subtask.description}`);
+                try {
+                    const success = await this.executeSubtaskWithAgent(subtask);
+                    if (success) {
+                        subtask.status = 'completed';
+                        console.log(`  ✅ ${subtask.description}`);
+                    }
+                    else {
+                        subtask.status = 'failed';
+                        subtask.retryCount++;
+                        console.log(`  ❌ ${subtask.description}`);
+                    }
+                }
+                catch (error) {
+                    subtask.status = 'failed';
+                    subtask.error = String(error);
+                    console.log(`  ❌ ${subtask.description}: ${error}`);
+                }
+                this.currentTask.updatedAt = new Date().toISOString();
+                await this.saveTask(this.currentTask);
+            });
+            await Promise.all(promises);
+            // Get next batch
+            batch = pendingSubtasks();
+        }
+        // Final status
+        const completed = this.currentTask.subtasks.filter(s => s.status === 'completed').length;
+        const failed = this.currentTask.subtasks.filter(s => s.status === 'failed').length;
+        console.log(`\n📊 Resumen paralelo:`);
+        console.log(`   ✅ Completadas: ${completed}/${this.currentTask.subtasks.length}`);
+        console.log(`   ❌ Fallidas: ${failed}/${this.currentTask.subtasks.length}`);
+    }
+    /**
+     * Verify that a subtask was completed successfully by checking output
+     */
+    async verifySubtask(subtask) {
+        // Verification logic based on subtask type
+        const verifyPrompt = subtask.prompt.toLowerCase();
+        try {
+            // Check for file creation tasks
+            if (verifyPrompt.includes('crea') || verifyPrompt.includes('create') || verifyPrompt.includes('file')) {
+                // List files to verify they exist
+                const { exec } = await import('child_process');
+                const { promisify } = await import('util');
+                const execAsync = promisify(exec);
+                const { stdout } = await execAsync('ls -la app/ components/ 2>/dev/null || echo "dirs not found"');
+                return stdout.length > 0 && !stdout.includes('not found');
+            }
+            // For now, assume verification passes
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async saveTask(task) {
+        await fs.mkdir(this.tasksDir, { recursive: true });
+        const filePath = path.join(this.tasksDir, `${task.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(task, null, 2));
+    }
+    async loadTask(taskId) {
+        try {
+            const filePath = path.join(this.tasksDir, `${taskId}.json`);
+            const content = await fs.readFile(filePath, 'utf-8');
+            this.currentTask = JSON.parse(content);
+            return this.currentTask;
+        }
+        catch {
+            return null;
+        }
+    }
+    getCurrentTask() {
+        return this.currentTask;
+    }
+    getProgress() {
+        if (!this.currentTask) {
+            return { completed: 0, total: 0, percentage: 0 };
+        }
+        const completed = this.currentTask.subtasks.filter(s => s.status === 'completed').length;
+        const total = this.currentTask.subtasks.length;
+        return {
+            completed,
+            total,
+            percentage: Math.round((completed / total) * 100),
+        };
+    }
+    /**
+     * Verify a project was created successfully by checking files exist
+     */
+    async verifyProject(projectType) {
+        const requiredFiles = {
+            portfolio: ['app/page.tsx', 'components/navbar.tsx', 'components/hero-section.tsx', 'package.json'],
+            saas: ['app/dashboard/page.tsx', 'app/api/user/route.ts', 'package.json'],
+            api: ['src/server.ts', 'package.json', 'tsconfig.json'],
+            mobile: ['App.tsx', 'package.json'],
+            ecommerce: ['app/products/page.tsx', 'components/cart.tsx', 'package.json'],
+            docs: ['pages/index.mdx', 'package.json'],
+        };
+        const files = requiredFiles[projectType] || [];
+        const missing = [];
+        for (const file of files) {
+            try {
+                await fs.access(path.join(process.cwd(), file));
+            }
+            catch {
+                missing.push(file);
+            }
+        }
+        return { success: missing.length === 0, missing };
+    }
+    /**
+     * Build the project and return success status
+     */
+    async buildProject() {
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        try {
+            // First install dependencies
+            console.log('📦 Installing dependencies...');
+            await execAsync('npm install', { timeout: 300000 });
+            // Then build
+            console.log('🔨 Building project...');
+            const { stdout, stderr } = await execAsync('npm run build', { timeout: 300000 });
+            return { success: true, output: stdout + stderr };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: error.stdout || '',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Start preview server and return URL
+     */
+    async startPreview(port) {
+        const { spawn } = await import('child_process');
+        const previewPort = port || 3000;
+        // Check if Next.js or other framework
+        const isNextJs = await this.checkFileExists('next.config.ts') || await this.checkFileExists('next.config.js');
+        const isVite = await this.checkFileExists('vite.config.ts') || await this.checkFileExists('vite.config.js');
+        let command;
+        let args;
+        if (isNextJs) {
+            command = 'npx';
+            args = ['next', 'start', '-p', previewPort.toString()];
+        }
+        else if (isVite) {
+            command = 'npx';
+            args = ['vite', 'preview', '--port', previewPort.toString()];
+        }
+        else {
+            command = 'npx';
+            args = ['serve', '-l', previewPort.toString(), 'dist'];
+        }
+        const previewProcess = spawn(command, args, {
+            stdio: 'pipe',
+            detached: false,
+        });
+        const url = `http://localhost:${previewPort}`;
+        // Wait a bit for server to start
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        return { url, process: previewProcess };
+    }
+    /**
+     * Deploy to Vercel (requires vercel CLI to be installed and logged in)
+     */
+    async deployToVercel() {
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        try {
+            console.log('🚀 Deploying to Vercel...');
+            const { stdout } = await execAsync('npx vercel --yes --prod', { timeout: 300000 });
+            // Extract URL from output
+            const urlMatch = stdout.match(/https?:\/\/[^\s]+\.vercel\.app/);
+            const url = urlMatch ? urlMatch[0] : undefined;
+            return { success: true, url };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Deploy failed'
+            };
+        }
+    }
+    /**
+     * Deploy to Netlify (requires netlify CLI to be installed and logged in)
+     */
+    async deployToNetlify() {
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        try {
+            console.log('🚀 Deploying to Netlify...');
+            const { stdout } = await execAsync('npx netlify deploy --prod --dir=dist', { timeout: 300000 });
+            // Extract URL from output
+            const urlMatch = stdout.match(/https?:\/\/[^\s]+\.netlify\.app/);
+            const url = urlMatch ? urlMatch[0] : undefined;
+            return { success: true, url };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Deploy failed'
+            };
+        }
+    }
+    async checkFileExists(filePath) {
+        try {
+            await fs.access(path.join(process.cwd(), filePath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export default TaskOrchestrator;
+//# sourceMappingURL=orchestrator.js.map