claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/swarm/direct-executor.js

@@ -1,1180 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { Logger } from "../core/logger.js";
-export class DirectTaskExecutor {
-    async executeTask(task, agent, targetDir) {
-        this.logger.info('Executing task directly', {
-            taskId: task.id.id,
-            taskName: task.name,
-            agentType: agent.type,
-            targetDir
-        });
-        const startTime = Date.now();
-        try {
-            // Ensure target directory exists
-            if (targetDir) {
-                await fs.mkdir(targetDir, {
-                    recursive: true
-                });
-            }
-            // Execute based on task type and objective
-            const result = await this.executeTaskByType(task, agent, targetDir);
-            const endTime = Date.now();
-            const executionTime = endTime - startTime;
-            return {
-                output: result,
-                artifacts: {},
-                metadata: {
-                    agentId: agent.id.id,
-                    agentType: agent.type,
-                    executionTime,
-                    targetDir
-                },
-                quality: 1.0,
-                completeness: 1.0,
-                accuracy: 1.0,
-                executionTime,
-                resourcesUsed: {
-                    cpuTime: executionTime,
-                    maxMemory: 0,
-                    diskIO: 0,
-                    networkIO: 0,
-                    fileHandles: 0
-                },
-                validated: true
-            };
-        } catch (error) {
-            this.logger.error('Task execution failed', {
-                taskId: task.id.id,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        }
-    }
-    async executeTaskByType(task, agent, targetDir) {
-        const objective = task.description.toLowerCase();
-        // Extract key information from the task
-        const isRestAPI = objective.includes('rest api') || objective.includes('crud');
-        const isTodo = objective.includes('todo');
-        const isChat = objective.includes('chat') || objective.includes('websocket');
-        const isAuth = objective.includes('auth') || objective.includes('jwt');
-        const isHelloWorld = objective.includes('hello world');
-        const isCalculator = objective.includes('calculator') || objective.includes('calc');
-        const isAnalysis = task.type === 'analysis' || objective.includes('analyze');
-        const isResearch = task.type === 'research' || objective.includes('research');
-        // Route to appropriate implementation based on agent type and task
-        switch(agent.type){
-            case 'analyst':
-                return this.executeAnalyzerTask(task, targetDir);
-            case 'coder':
-                if (isRestAPI) return this.createRestAPI(targetDir, task);
-                if (isTodo) return this.createTodoApp(targetDir, task);
-                if (isChat) return this.createChatApp(targetDir, task);
-                if (isAuth) return this.createAuthService(targetDir, task);
-                if (isHelloWorld) return this.createHelloWorld(targetDir, task);
-                if (isCalculator) return this.createCalculator(targetDir, task);
-                return this.createGenericApp(targetDir, task);
-            case 'tester':
-                return this.executeTestingTask(task, targetDir);
-            case 'reviewer':
-                if (task.name.toLowerCase().includes('analyze') || task.name.toLowerCase().includes('plan')) {
-                    return this.executeAnalyzerTask(task, targetDir);
-                }
-                return this.executeReviewTask(task, targetDir);
-            case 'documenter':
-                return this.executeDocumentationTask(task, targetDir);
-            case 'researcher':
-                return this.executeResearchTask(task, targetDir);
-            case 'coordinator':
-                return this.executeCoordinationTask(task, targetDir);
-            default:
-                return this.executeGenericTask(task, targetDir);
-        }
-    }
-    async executeAnalyzerTask(task, targetDir) {
-        this.logger.info('Executing analyzer task', {
-            taskName: task.name
-        });
-        const analysis = {
-            taskName: task.name,
-            objective: task.description,
-            analysis: {
-                requirements: this.extractRequirements(task.description),
-                components: this.identifyComponents(task.description),
-                technologies: this.suggestTechnologies(task.description),
-                architecture: this.suggestArchitecture(task.description)
-            },
-            recommendations: [],
-            executionPlan: []
-        };
-        if (targetDir) {
-            await fs.writeFile(path.join(targetDir, 'analysis.json'), JSON.stringify(analysis, null, 2));
-        }
-        return analysis;
-    }
-    async createRestAPI(targetDir, task) {
-        this.logger.info('Creating REST API', {
-            targetDir
-        });
-        const files = {
-            'server.js': this.generateRestAPIServer(task),
-            'package.json': this.generatePackageJson('rest-api', [
-                'express',
-                'cors',
-                'dotenv'
-            ]),
-            'README.md': this.generateReadme('REST API', task),
-            '.env.example': 'PORT=3000\nDATABASE_URL=',
-            '.gitignore': 'node_modules/\n.env\n*.log'
-        };
-        // Create middleware and routes directories
-        await fs.mkdir(path.join(targetDir, 'routes'), {
-            recursive: true
-        });
-        await fs.mkdir(path.join(targetDir, 'middleware'), {
-            recursive: true
-        });
-        await fs.mkdir(path.join(targetDir, 'models'), {
-            recursive: true
-        });
-        // Write all files
-        for (const [filename, content] of Object.entries(files)){
-            await fs.writeFile(path.join(targetDir, filename), content);
-        }
-        // Add route files
-        await fs.writeFile(path.join(targetDir, 'routes', 'users.js'), this.generateUserRoutes());
-        return {
-            filesCreated: Object.keys(files).length + 1,
-            structure: 'REST API with Express',
-            targetDir
-        };
-    }
-    async createTodoApp(targetDir, task) {
-        this.logger.info('Creating Todo App', {
-            targetDir
-        });
-        const files = {
-            'app.js': this.generateTodoApp(task),
-            'package.json': this.generatePackageJson('todo-app', [
-                'commander',
-                'chalk'
-            ]),
-            'README.md': this.generateReadme('Todo List Application', task),
-            'todos.json': '[]'
-        };
-        for (const [filename, content] of Object.entries(files)){
-            await fs.writeFile(path.join(targetDir, filename), content);
-        }
-        return {
-            filesCreated: Object.keys(files).length,
-            structure: 'CLI Todo Application',
-            targetDir
-        };
-    }
-    async createChatApp(targetDir, task) {
-        this.logger.info('Creating Chat Application', {
-            targetDir
-        });
-        const files = {
-            'server.js': this.generateChatServer(task),
-            'index.html': this.generateChatHTML(),
-            'client.js': this.generateChatClient(),
-            'package.json': this.generatePackageJson('chat-app', [
-                'express',
-                'socket.io'
-            ]),
-            'README.md': this.generateReadme('Real-time Chat Application', task)
-        };
-        await fs.mkdir(path.join(targetDir, 'public'), {
-            recursive: true
-        });
-        await fs.writeFile(path.join(targetDir, 'server.js'), files['server.js']);
-        await fs.writeFile(path.join(targetDir, 'package.json'), files['package.json']);
-        await fs.writeFile(path.join(targetDir, 'README.md'), files['README.md']);
-        await fs.writeFile(path.join(targetDir, 'public', 'index.html'), files['index.html']);
-        await fs.writeFile(path.join(targetDir, 'public', 'client.js'), files['client.js']);
-        return {
-            filesCreated: Object.keys(files).length,
-            structure: 'WebSocket Chat Application',
-            targetDir
-        };
-    }
-    async createAuthService(targetDir, task) {
-        this.logger.info('Creating Auth Service', {
-            targetDir
-        });
-        const files = {
-            'server.js': this.generateAuthServer(task),
-            'auth.js': this.generateAuthMiddleware(),
-            'package.json': this.generatePackageJson('auth-service', [
-                'express',
-                'jsonwebtoken',
-                'bcrypt'
-            ]),
-            'README.md': this.generateReadme('Authentication Service', task),
-            '.env.example': 'JWT_SECRET=your-secret-key\nPORT=3000'
-        };
-        await fs.mkdir(path.join(targetDir, 'middleware'), {
-            recursive: true
-        });
-        await fs.writeFile(path.join(targetDir, 'server.js'), files['server.js']);
-        await fs.writeFile(path.join(targetDir, 'middleware', 'auth.js'), files['auth.js']);
-        await fs.writeFile(path.join(targetDir, 'package.json'), files['package.json']);
-        await fs.writeFile(path.join(targetDir, 'README.md'), files['README.md']);
-        await fs.writeFile(path.join(targetDir, '.env.example'), files['.env.example']);
-        return {
-            filesCreated: Object.keys(files).length,
-            structure: 'JWT Authentication Service',
-            targetDir
-        };
-    }
-    async createCalculator(targetDir, task) {
-        this.logger.info('Creating Calculator', {
-            targetDir
-        });
-        const files = {
-            'calculator.js': `class Calculator {
-  add(a, b) {
-    return a + b;
-  }
-
-  subtract(a, b) {
-    return a - b;
-  }
-
-  multiply(a, b) {
-    return a * b;
-  }
-
-  divide(a, b) {
-    if (b === 0) {
-      throw new Error('Division by zero');
-    }
-    return a / b;
-  }
-
-  power(base, exponent) {
-    return Math.pow(base, exponent);
-  }
-
-  sqrt(n) {
-    if (n < 0) {
-      throw new Error('Cannot calculate square root of negative number');
-    }
-    return Math.sqrt(n);
-  }
-}
-
-module.exports = Calculator;
-`,
-            'cli.js': `#!/usr/bin/env node
-const Calculator = require('./calculator');
-const readline = require('readline');
-
-const calc = new Calculator();
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-});
-
-console.log('Simple Calculator');
-console.log('Available operations: add, subtract, multiply, divide, power, sqrt');
-console.log('Type "exit" to quit\\n');
-
-function prompt() {
-  rl.question('Enter operation: ', (operation) => {
-    if (operation === 'exit') {
-      rl.close();
-      return;
-    }
-
-    if (operation === 'sqrt') {
-      rl.question('Enter number: ', (num) => {
-        try {
-          const result = calc.sqrt(parseFloat(num));
-          console.log(\`Result: \${result}\\n\`);
-        } catch (error) {
-          console.log(\`Error: \${(error instanceof Error ? error.message : String(error))}\\n\`);
-        }
-        prompt();
-      });
-    } else {
-      rl.question('Enter first number: ', (num1) => {
-        rl.question('Enter second number: ', (num2) => {
-          try {
-            const a = parseFloat(num1);
-            const b = parseFloat(num2);
-            let result;
-
-            switch (operation) {
-              case 'add':
-                result = calc.add(a, b);
-                break;
-              case 'subtract':
-                result = calc.subtract(a, b);
-                break;
-              case 'multiply':
-                result = calc.multiply(a, b);
-                break;
-              case 'divide':
-                result = calc.divide(a, b);
-                break;
-              case 'power':
-                result = calc.power(a, b);
-                break;
-              default:
-                console.log('Invalid operation\\n');
-                prompt();
-                return;
-            }
-
-            console.log(\`Result: \${result}\\n\`);
-          } catch (error) {
-            console.log(\`Error: \${(error instanceof Error ? error.message : String(error))}\\n\`);
-          }
-          prompt();
-        });
-      });
-    }
-  });
-}
-
-prompt();
-`,
-            'test.js': `const Calculator = require('./calculator');
-const assert = require('assert');
-
-const calc = new Calculator();
-
-// Test addition
-assert.strictEqual(calc.add(2, 3), 5);
-assert.strictEqual(calc.add(-1, 1), 0);
-
-// Test subtraction
-assert.strictEqual(calc.subtract(5, 3), 2);
-assert.strictEqual(calc.subtract(0, 5), -5);
-
-// Test multiplication
-assert.strictEqual(calc.multiply(3, 4), 12);
-assert.strictEqual(calc.multiply(-2, 3), -6);
-
-// Test division
-assert.strictEqual(calc.divide(10, 2), 5);
-assert.strictEqual(calc.divide(7, 2), 3.5);
-
-// Test division by zero
-assert.throws(() => calc.divide(5, 0), /Division by zero/);
-
-// Test power
-assert.strictEqual(calc.power(2, 3), 8);
-assert.strictEqual(calc.power(5, 0), 1);
-
-// Test square root
-assert.strictEqual(calc.sqrt(16), 4);
-assert.strictEqual(calc.sqrt(2), Math.sqrt(2));
-
-// Test negative square root
-assert.throws(() => calc.sqrt(-1), /Cannot calculate square root of negative number/);
-
-console.log('All tests passed! ✅');
-`,
-            'package.json': this.generatePackageJson('calculator-app', []),
-            'README.md': `# Calculator Application
-
-A simple calculator with basic mathematical operations.
-
-## Features
-- Addition
-- Subtraction
-- Multiplication
-- Division
-- Power
-- Square Root
-
-## Installation
-\`\`\`bash
-npm install
-\`\`\`
-
-## Usage
-
-### CLI Mode
-\`\`\`bash
-node cli.js
-\`\`\`
-
-### Programmatic Usage
-\`\`\`javascript
-const Calculator = require('./calculator');
-const calc = new Calculator();
-
-console.log(calc.add(5, 3)); // 8
-console.log(calc.multiply(4, 7)); // 28
-\`\`\`
-
-## Testing
-\`\`\`bash
-npm test
-\`\`\`
-
-Created by Claude Flow Swarm
-`
-        };
-        // Update package.json with test script
-        const pkgJson = JSON.parse(files['package.json']);
-        pkgJson.scripts.test = 'node test.js';
-        pkgJson.main = 'calculator.js';
-        files['package.json'] = JSON.stringify(pkgJson, null, 2);
-        for (const [filename, content] of Object.entries(files)){
-            await fs.writeFile(path.join(targetDir, filename), content);
-        }
-        return {
-            filesCreated: Object.keys(files).length,
-            structure: 'Calculator with CLI and tests',
-            targetDir
-        };
-    }
-    async createHelloWorld(targetDir, task) {
-        this.logger.info('Creating Hello World', {
-            targetDir
-        });
-        const files = {
-            'index.js': `#!/usr/bin/env node
-console.log('Hello, World!');
-console.log('Created by Claude Flow Swarm');
-`,
-            'package.json': this.generatePackageJson('hello-world', []),
-            'README.md': this.generateReadme('Hello World Application', task)
-        };
-        for (const [filename, content] of Object.entries(files)){
-            await fs.writeFile(path.join(targetDir, filename), content);
-        }
-        return {
-            filesCreated: Object.keys(files).length,
-            structure: 'Simple Hello World',
-            targetDir
-        };
-    }
-    async createGenericApp(targetDir, task) {
-        this.logger.info('Creating generic application', {
-            targetDir
-        });
-        const files = {
-            'app.js': this.generateGenericApp(task),
-            'package.json': this.generatePackageJson('app', []),
-            'README.md': this.generateReadme('Application', task)
-        };
-        for (const [filename, content] of Object.entries(files)){
-            await fs.writeFile(path.join(targetDir, filename), content);
-        }
-        return {
-            filesCreated: Object.keys(files).length,
-            structure: 'Generic Application',
-            targetDir
-        };
-    }
-    async executeTestingTask(task, targetDir) {
-        this.logger.info('Executing testing task', {
-            taskName: task.name
-        });
-        const testPlan = {
-            taskName: task.name,
-            testStrategy: 'Comprehensive testing approach',
-            testCases: [
-                'Unit tests for core functionality',
-                'Integration tests for API endpoints',
-                'Performance tests for scalability',
-                'Security tests for vulnerabilities'
-            ],
-            coverage: 'Target 80% code coverage'
-        };
-        if (targetDir) {
-            await fs.writeFile(path.join(targetDir, 'test-plan.json'), JSON.stringify(testPlan, null, 2));
-        }
-        return testPlan;
-    }
-    async executeReviewTask(task, targetDir) {
-        this.logger.info('Executing review task', {
-            taskName: task.name
-        });
-        const review = {
-            taskName: task.name,
-            reviewType: 'Code Quality Review',
-            findings: [
-                'Code follows best practices',
-                'Proper error handling implemented',
-                'Documentation is comprehensive'
-            ],
-            recommendations: [
-                'Consider adding more unit tests',
-                'Optimize database queries',
-                'Add input validation'
-            ]
-        };
-        if (targetDir) {
-            await fs.writeFile(path.join(targetDir, 'review.json'), JSON.stringify(review, null, 2));
-        }
-        return review;
-    }
-    async executeDocumentationTask(task, targetDir) {
-        this.logger.info('Executing documentation task', {
-            taskName: task.name
-        });
-        const docs = `# Documentation
-
-## Overview
-${task.description}
-
-## Installation
-\`\`\`bash
-npm install
-\`\`\`
-
-## Usage
-Follow the instructions in the README file.
-
-## API Reference
-See the generated API documentation.
-`;
-        if (targetDir) {
-            await fs.writeFile(path.join(targetDir, 'DOCS.md'), docs);
-        }
-        return {
-            documentation: 'Created',
-            location: targetDir
-        };
-    }
-    async executeResearchTask(task, targetDir) {
-        this.logger.info('Executing research task', {
-            taskName: task.name
-        });
-        const research = {
-            taskName: task.name,
-            findings: [
-                'Best practices identified',
-                'Similar implementations analyzed',
-                'Performance benchmarks reviewed'
-            ],
-            recommendations: [
-                'Use established patterns',
-                'Follow industry standards',
-                'Implement security best practices'
-            ]
-        };
-        if (targetDir) {
-            await fs.writeFile(path.join(targetDir, 'research.json'), JSON.stringify(research, null, 2));
-        }
-        return research;
-    }
-    async executeCoordinationTask(task, targetDir) {
-        this.logger.info('Executing coordination task', {
-            taskName: task.name
-        });
-        return {
-            taskName: task.name,
-            coordination: 'Task coordination completed',
-            subtasks: 'All subtasks have been delegated'
-        };
-    }
-    async executeGenericTask(task, targetDir) {
-        this.logger.info('Executing generic task', {
-            taskName: task.name
-        });
-        return {
-            taskName: task.name,
-            status: 'Completed',
-            description: task.description
-        };
-    }
-    // Helper methods for generating code
-    generateRestAPIServer(task) {
-        return `const express = require('express');
-const cors = require('cors');
-require('dotenv').config();
-
-const app = express();
-const port = process.env.PORT || 3000;
-
-// Middleware
-app.use(cors());
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
-
-// Routes
-app.use('/api/users', require('./routes/users'));
-
-// Health check
-app.get('/health', (req, res) => {
-  res.json({ status: 'healthy', service: 'REST API' });
-});
-
-// Error handling
-app.use((err, req, res, next) => {
-  console.error(err.stack);
-  res.status(500).json({ error: 'Internal server error' });
-});
-
-app.listen(port, () => {
-  console.log(\`Server running on port \${port}\`);
-});
-
-module.exports = app;
-`;
-    }
-    generateUserRoutes() {
-        return `const express = require('express');
-const router = express.Router();
-
-// In-memory storage (replace with database)
-let users = [];
-let nextId = 1;
-
-// GET all users
-router.get('/', (req, res) => {
-  res.json(users);
-});
-
-// GET user by ID
-router.get('/:id', (req, res) => {
-  const user = users.find(u => u.id === parseInt(req.params.id));
-  if (!user) return res.status(404).json({ error: 'User not found' });
-  res.json(user);
-});
-
-// POST create user
-router.post('/', (req, res) => {
-  const user = {
-    id: nextId++,
-    ...req.body,
-    createdAt: new Date()
-  };
-  users.push(user);
-  res.status(201).json(user);
-});
-
-// PUT update user
-router.put('/:id', (req, res) => {
-  const index = users.findIndex(u => u.id === parseInt(req.params.id));
-  if (index === -1) return res.status(404).json({ error: 'User not found' });
-  
-  users[index] = {
-    ...users[index],
-    ...req.body,
-    updatedAt: new Date()
-  };
-  res.json(users[index]);
-});
-
-// DELETE user
-router.delete('/:id', (req, res) => {
-  const index = users.findIndex(u => u.id === parseInt(req.params.id));
-  if (index === -1) return res.status(404).json({ error: 'User not found' });
-  
-  users.splice(index, 1);
-  res.status(204).send();
-});
-
-module.exports = router;
-`;
-    }
-    generateTodoApp(task) {
-        return `#!/usr/bin/env node
-const { program } = require('commander');
-const chalk = require('chalk');
-const fs = require('fs').promises;
-const path = require('path');
-
-const TODO_FILE = path.join(__dirname, 'todos.json');
-
-// Load todos
-async function loadTodos() {
-  try {
-    const data = await fs.readFile(TODO_FILE, 'utf8');
-    return JSON.parse(data);
-  } catch {
-    return [];
-  }
-}
-
-// Save todos
-async function saveTodos(todos) {
-  await fs.writeFile(TODO_FILE, JSON.stringify(todos, null, 2));
-}
-
-// Add todo
-program
-  .command('add <task>')
-  .description('Add a new todo')
-  .action(async (task) => {
-    const todos = await loadTodos();
-    const todo = {
-      id: Date.now(),
-      task,
-      completed: false,
-      createdAt: new Date()
-    };
-    todos.push(todo);
-    await saveTodos(todos);
-    console.log(chalk.green('✓ Todo added:', task));
-  });
-
-// List todos
-program
-  .command('list')
-  .description('List all todos')
-  .action(async () => {
-    const todos = await loadTodos();
-    if (todos.length === 0) {
-      console.log(chalk.yellow('No todos found'));
-      return;
-    }
-    
-    todos.forEach((todo, index) => {
-      const status = todo.completed ? chalk.green('✓') : chalk.red('✗');
-      console.log(\`\${index + 1}. \${status} \${todo.task}\`);
-    });
-  });
-
-// Remove todo
-program
-  .command('remove <id>')
-  .description('Remove a todo by ID')
-  .action(async (id) => {
-    const todos = await loadTodos();
-    const index = parseInt(id) - 1;
-    if (index < 0 || index >= todos.length) {
-      console.log(chalk.red('Invalid todo ID'));
-      return;
-    }
-    
-    const removed = todos.splice(index, 1);
-    await saveTodos(todos);
-    console.log(chalk.green('✓ Todo removed:', removed[0].task));
-  });
-
-// Complete todo
-program
-  .command('done <id>')
-  .description('Mark todo as completed')
-  .action(async (id) => {
-    const todos = await loadTodos();
-    const index = parseInt(id) - 1;
-    if (index < 0 || index >= todos.length) {
-      console.log(chalk.red('Invalid todo ID'));
-      return;
-    }
-    
-    todos[index].completed = true;
-    todos[index].completedAt = new Date();
-    await saveTodos(todos);
-    console.log(chalk.green('✓ Todo completed:', todos[index].task));
-  });
-
-program.parse(process.argv);
-`;
-    }
-    generateChatServer(task) {
-        return `const express = require('express');
-const http = require('http');
-const socketIo = require('socket.io');
-const path = require('path');
-
-const app = express();
-const server = http.createServer(app);
-const io = socketIo(server);
-
-app.use(express.static('public'));
-
-const messages = [];
-const users = new Map();
-
-io.on('connection', (socket) => {
-  console.log('New user connected');
-  
-  socket.on('join', (username) => {
-    users.set(socket.id, username);
-    socket.emit('history', messages);
-    io.emit('userJoined', { username, userCount: users.size });
-  });
-  
-  socket.on('message', (data) => {
-    const message = {
-      id: Date.now(),
-      username: users.get(socket.id) || 'Anonymous',
-      text: data.text,
-      timestamp: new Date()
-    };
-    
-    messages.push(message);
-    if (messages.length > 100) messages.shift(); // Keep last 100 messages
-    
-    io.emit('message', message);
-  });
-  
-  socket.on('disconnect', () => {
-    const username = users.get(socket.id);
-    users.delete(socket.id);
-    if (username) {
-      io.emit('userLeft', { username, userCount: users.size });
-    }
-  });
-});
-
-const PORT = process.env.PORT || 3000;
-server.listen(PORT, () => {
-  console.log(\`Chat server running on port \${PORT}\`);
-});
-`;
-    }
-    generateChatHTML() {
-        return `<!DOCTYPE html>
-<html>
-<head>
-  <title>Chat App</title>
-  <style>
-    body { font-family: Arial, sans-serif; margin: 0; padding: 20px; }
-    #messages { height: 400px; overflow-y: auto; border: 1px solid #ccc; padding: 10px; margin-bottom: 10px; }
-    .message { margin-bottom: 10px; }
-    .timestamp { color: #666; font-size: 0.8em; }
-    #messageForm { display: flex; gap: 10px; }
-    #messageInput { flex: 1; padding: 10px; }
-    button { padding: 10px 20px; }
-  </style>
-</head>
-<body>
-  <h1>Real-time Chat</h1>
-  <div id="userCount">Users: 0</div>
-  <div id="messages"></div>
-  <form id="messageForm">
-    <input type="text" id="messageInput" placeholder="Type a message..." required>
-    <button type="submit">Send</button>
-  </form>
-  <script src="/socket.io/socket.io.js"></script>
-  <script src="client.js"></script>
-</body>
-</html>
-`;
-    }
-    generateChatClient() {
-        return `const socket = io();
-const messagesDiv = document.getElementById('messages');
-const messageForm = document.getElementById('messageForm');
-const messageInput = document.getElementById('messageInput');
-const userCountDiv = document.getElementById('userCount');
-
-const username = prompt('Enter your username:') || 'Anonymous';
-socket.emit('join', username);
-
-socket.on('history', (messages) => {
-  messages.forEach(displayMessage);
-});
-
-socket.on('message', displayMessage);
-
-socket.on('userJoined', ({ username, userCount }) => {
-  displaySystemMessage(\`\${username} joined the chat\`);
-  updateUserCount(userCount);
-});
-
-socket.on('userLeft', ({ username, userCount }) => {
-  displaySystemMessage(\`\${username} left the chat\`);
-  updateUserCount(userCount);
-});
-
-messageForm.addEventListener('submit', (e) => {
-  e.preventDefault();
-  const text = messageInput.value.trim();
-  if (text) {
-    socket.emit('message', { text });
-    messageInput.value = '';
-  }
-});
-
-function displayMessage(message) {
-  const div = document.createElement('div');
-  div.className = 'message';
-  div.innerHTML = \`
-    <strong>\${message.username}:</strong> \${message.text}
-    <span class="timestamp">\${new Date(message.timestamp).toLocaleTimeString()}</span>
-  \`;
-  messagesDiv.appendChild(div);
-  messagesDiv.scrollTop = messagesDiv.scrollHeight;
-}
-
-function displaySystemMessage(text) {
-  const div = document.createElement('div');
-  div.className = 'message system';
-  div.style.fontStyle = 'italic';
-  div.style.color = '#666';
-  div.textContent = text;
-  messagesDiv.appendChild(div);
-  messagesDiv.scrollTop = messagesDiv.scrollHeight;
-}
-
-function updateUserCount(count) {
-  userCountDiv.textContent = \`Users: \${count}\`;
-}
-`;
-    }
-    generateAuthServer(task) {
-        return `const express = require('express');
-const jwt = require('jsonwebtoken');
-const bcrypt = require('bcrypt');
-require('dotenv').config();
-
-const app = express();
-const port = process.env.PORT || 3000;
-
-app.use(express.json());
-
-// In-memory user storage (use database in production)
-const users = [];
-
-// Register endpoint
-app.post('/api/register', async (req, res) => {
-  try {
-    const { username, password } = req.body;
-    
-    // Check if user exists
-    if (users.find(u => u.username === username)) {
-      return res.status(400).json({ error: 'User already exists' });
-    }
-    
-    // Hash password
-    const hashedPassword = await bcrypt.hash(password, 10);
-    
-    // Create user
-    const user = {
-      id: users.length + 1,
-      username,
-      password: hashedPassword
-    };
-    
-    users.push(user);
-    
-    // Generate token
-    const token = jwt.sign(
-      { id: user.id, username: user.username },
-      process.env.JWT_SECRET || 'default-secret',
-      { expiresIn: '24h' }
-    );
-    
-    res.status(201).json({ token, user: { id: user.id, username: user.username } });
-  } catch (error) {
-    res.status(500).json({ error: 'Registration failed' });
-  }
-});
-
-// Login endpoint
-app.post('/api/login', async (req, res) => {
-  try {
-    const { username, password } = req.body;
-    
-    // Find user
-    const user = users.find(u => u.username === username);
-    if (!user) {
-      return res.status(401).json({ error: 'Invalid credentials' });
-    }
-    
-    // Verify password
-    const validPassword = await bcrypt.compare(password, user.password);
-    if (!validPassword) {
-      return res.status(401).json({ error: 'Invalid credentials' });
-    }
-    
-    // Generate token
-    const token = jwt.sign(
-      { id: user.id, username: user.username },
-      process.env.JWT_SECRET || 'default-secret',
-      { expiresIn: '24h' }
-    );
-    
-    res.json({ token, user: { id: user.id, username: user.username } });
-  } catch (error) {
-    res.status(500).json({ error: 'Login failed' });
-  }
-});
-
-// Protected route example
-app.get('/api/profile', require('./middleware/auth'), (req, res) => {
-  res.json({ user: req.user });
-});
-
-app.listen(port, () => {
-  console.log(\`Auth service running on port \${port}\`);
-});
-`;
-    }
-    generateAuthMiddleware() {
-        return `const jwt = require('jsonwebtoken');
-
-module.exports = (req, res, next) => {
-  const token = req.header('Authorization')?.replace('Bearer ', '');
-  
-  if (!token) {
-    return res.status(401).json({ error: 'Access denied' });
-  }
-  
-  try {
-    const verified = jwt.verify(token, process.env.JWT_SECRET || 'default-secret');
-    req.user = verified;
-    next();
-  } catch (error) {
-    res.status(401).json({ error: 'Invalid token' });
-  }
-};
-`;
-    }
-    generatePackageJson(name, dependencies) {
-        const deps = {};
-        dependencies.forEach((dep)=>{
-            deps[dep] = '^latest';
-        });
-        const pkg = {
-            name,
-            version: '1.0.0',
-            description: `${name} created by Claude Flow Swarm`,
-            main: 'server.js',
-            scripts: {
-                start: 'node server.js',
-                dev: 'nodemon server.js',
-                test: 'echo "No tests yet"'
-            },
-            keywords: [
-                'swarm',
-                'claude-flow'
-            ],
-            author: 'Claude Flow Swarm',
-            license: 'MIT',
-            dependencies: deps
-        };
-        return JSON.stringify(pkg, null, 2);
-    }
-    generateReadme(title, task) {
-        return `# ${title}
-
-Created by Claude Flow Swarm
-
-## Overview
-${task.description}
-
-## Installation
-\`\`\`bash
-npm install
-\`\`\`
-
-## Usage
-\`\`\`bash
-npm start
-\`\`\`
-
-## Development
-\`\`\`bash
-npm run dev
-\`\`\`
-
-## Task Details
-- Task ID: ${task.id.id}
-- Task Type: ${task.type}
-- Created: ${new Date().toISOString()}
-`;
-    }
-    generateGenericApp(task) {
-        return `// Application created by Claude Flow Swarm
-// Task: ${task.name}
-// Description: ${task.description}
-
-function main() {
-  console.log('Executing: ${task.description}');
-  // Implementation goes here
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { main };
-`;
-    }
-    // Analysis helper methods
-    extractRequirements(description) {
-        const requirements = [];
-        if (description.includes('rest api') || description.includes('crud')) {
-            requirements.push('RESTful API endpoints', 'CRUD operations', 'Data validation');
-        }
-        if (description.includes('auth')) {
-            requirements.push('User authentication', 'JWT tokens', 'Password hashing');
-        }
-        if (description.includes('real-time') || description.includes('websocket')) {
-            requirements.push('WebSocket support', 'Real-time communication', 'Message broadcasting');
-        }
-        if (description.includes('todo')) {
-            requirements.push('Task management', 'CRUD for todos', 'Status tracking');
-        }
-        return requirements;
-    }
-    identifyComponents(description) {
-        const components = [];
-        if (description.includes('api')) components.push('API Server', 'Route Handlers');
-        if (description.includes('auth')) components.push('Auth Middleware', 'Token Manager');
-        if (description.includes('database')) components.push('Database Models', 'Data Access Layer');
-        if (description.includes('frontend')) components.push('UI Components', 'Client Application');
-        return components;
-    }
-    suggestTechnologies(description) {
-        const tech = [];
-        if (description.includes('rest') || description.includes('api')) {
-            tech.push('Express.js', 'Node.js');
-        }
-        if (description.includes('real-time') || description.includes('chat')) {
-            tech.push('Socket.io', 'WebSockets');
-        }
-        if (description.includes('auth')) {
-            tech.push('JWT', 'bcrypt');
-        }
-        if (description.includes('database')) {
-            tech.push('MongoDB', 'PostgreSQL');
-        }
-        return tech;
-    }
-    suggestArchitecture(description) {
-        if (description.includes('microservice')) {
-            return 'Microservices architecture with API Gateway';
-        }
-        if (description.includes('real-time')) {
-            return 'Event-driven architecture with WebSocket layer';
-        }
-        if (description.includes('crud') || description.includes('rest')) {
-            return 'RESTful architecture with MVC pattern';
-        }
-        return 'Modular monolithic architecture';
-    }
-    constructor(config = {}){
-        _define_property(this, "logger", void 0);
-        _define_property(this, "timeout", void 0);
-        this.logger = config.logger || new Logger({
-            level: 'info',
-            format: 'text',
-            destination: 'console'
-        }, {
-            component: 'DirectTaskExecutor'
-        });
-        this.timeout = config.timeout || 300000; // 5 minutes default
-    }
-}