@itz4blitz/agentful 0.1.0 → 0.1.4

package/lib/agent-generator.js

@@ -0,0 +1,685 @@
+/**
+ * Smart Agent Generation System
+ *
+ * Analyzes codebase and generates contextually-aware agents
+ * that understand the project's tech stack, patterns, and conventions.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import TemplateEngine from './template-engine.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+class AgentGenerator {
+  constructor(projectPath, analysis) {
+    this.projectPath = projectPath;
+    this.analysis = analysis;
+    this.templatesDir = path.join(__dirname, '../templates/agents');
+    this.agentsDir = path.join(projectPath, '.claude/agents/auto-generated');
+  }
+
+  /**
+   * Main entry point - generates all agents based on analysis
+   */
+  async generateAgents() {
+    console.log('🤖 Generating agents...');
+
+    // Ensure agents directory exists
+    await fs.mkdir(this.agentsDir, { recursive: true });
+
+    // Generate core agents (always)
+    const coreAgents = await this.generateCoreAgents();
+
+    // Generate domain agents (conditional based on detected domains)
+    const domainAgents = await this.generateDomainAgents();
+
+    // Generate tech-specific agents (conditional based on tech stack)
+    const techAgents = await this.generateTechAgents();
+
+    // Update architecture.json with generated agent info
+    await this.updateArchitectureConfig({
+      core: coreAgents,
+      domains: domainAgents,
+      tech: techAgents,
+    });
+
+    console.log(`✅ Generated ${coreAgents.length + domainAgents.length + techAgents.length} agents`);
+
+    return {
+      core: coreAgents,
+      domains: domainAgents,
+      tech: techAgents,
+    };
+  }
+
+  /**
+   * Generate core agents (always needed)
+   */
+  async generateCoreAgents() {
+    const coreAgentTypes = ['backend', 'frontend', 'tester', 'reviewer', 'fixer'];
+
+    const agents = [];
+
+    for (const type of coreAgentTypes) {
+      const agentPath = path.join(this.agentsDir, `${type}.md`);
+      const template = await this.loadTemplate(`${type}-agent.template.md`);
+
+      if (!template) {
+        console.warn(`⚠️  No template found for ${type}, skipping`);
+        continue;
+      }
+
+      // Extract patterns from actual code
+      const patterns = await this.extractPatterns(type);
+
+      // Interpolate template with project-specific data
+      const content = TemplateEngine.render(template, {
+        language: this.analysis.primaryLanguage || 'javascript',
+        framework: this.analysis.primaryFramework || 'custom',
+        patterns: patterns.code,
+        conventions: patterns.conventions,
+        samples: patterns.samples,
+        generated_at: new Date().toISOString(),
+      });
+
+      await fs.writeFile(agentPath, content);
+      agents.push({ type, path: agentPath });
+    }
+
+    return agents;
+  }
+
+  /**
+   * Generate domain-specific agents (auth, billing, etc.)
+   */
+  async generateDomainAgents() {
+    const domains = this.analysis.domains || [];
+    const agents = [];
+
+    for (const domain of domains) {
+      const agentPath = path.join(this.agentsDir, `${domain.name}-agent.md`);
+
+      // Extract domain-specific code samples
+      const samples = await this.extractDomainSamples(domain);
+
+      // Generate domain context
+      const domainContext = {
+        domain: domain.name,
+        features: domain.features || [],
+        language: this.analysis.primaryLanguage || 'javascript',
+        framework: this.analysis.primaryFramework || 'custom',
+        confidence: domain.confidence || 0.5,
+        codeSamples: samples.code,
+        patterns: samples.patterns,
+        endpoints: samples.endpoints,
+        models: samples.models,
+        generated_at: new Date().toISOString(),
+      };
+
+      const template = await this.loadTemplate('domain-agent.template.md');
+      const content = TemplateEngine.render(template, domainContext);
+
+      await fs.writeFile(agentPath, content);
+      agents.push({ type: domain.name, path: agentPath });
+    }
+
+    return agents;
+  }
+
+  /**
+   * Generate tech-specific agents (Next.js, Prisma, etc.)
+   */
+  async generateTechAgents() {
+    const techStack = this.analysis.techStack || {};
+    const agents = [];
+
+    // Framework-specific agents
+    if (techStack.framework) {
+      const framework = techStack.framework.toLowerCase();
+      if (['nextjs', 'nuxt', 'remix'].includes(framework)) {
+        const agent = await this.generateFrameworkAgent(framework);
+        if (agent) agents.push(agent);
+      }
+    }
+
+    // ORM-specific agents
+    if (techStack.orm) {
+      const orm = techStack.orm.toLowerCase();
+      if (['prisma', 'drizzle', 'typeorm', 'mongoose'].includes(orm)) {
+        const agent = await this.generateORMAgent(orm);
+        if (agent) agents.push(agent);
+      }
+    }
+
+    // Database-specific agents
+    if (techStack.database) {
+      const db = techStack.database.toLowerCase();
+      if (['postgresql', 'mongodb', 'mysql', 'sqlite'].includes(db)) {
+        const agent = await this.generateDatabaseAgent(db);
+        if (agent) agents.push(agent);
+      }
+    }
+
+    return agents;
+  }
+
+  /**
+   * Generate framework-specific agent
+   */
+  async generateFrameworkAgent(framework) {
+    const agentPath = path.join(this.agentsDir, `${framework}-agent.md`);
+    const template = await this.loadTemplate('tech-agent.template.md');
+
+    if (!template) return null;
+
+    const samples = await this.extractFrameworkSamples(framework);
+
+    const content = TemplateEngine.render(template, {
+      tech: framework,
+      techType: 'framework',
+      language: this.analysis.primaryLanguage || 'javascript',
+      framework: framework,
+      patterns: samples.patterns,
+      conventions: samples.conventions,
+      samples: samples.code,
+      generated_at: new Date().toISOString(),
+    });
+
+    await fs.writeFile(agentPath, content);
+    return { type: framework, path: agentPath };
+  }
+
+  /**
+   * Generate ORM-specific agent
+   */
+  async generateORMAgent(orm) {
+    const agentPath = path.join(this.agentsDir, `${orm}-agent.md`);
+    const template = await this.loadTemplate('tech-agent.template.md');
+
+    if (!template) return null;
+
+    const samples = await this.extractORMSamples(orm);
+
+    const content = TemplateEngine.render(template, {
+      tech: orm,
+      techType: 'orm',
+      language: this.analysis.primaryLanguage || 'javascript',
+      framework: this.analysis.primaryFramework || 'custom',
+      patterns: samples.patterns,
+      conventions: samples.conventions,
+      samples: samples.code,
+      generated_at: new Date().toISOString(),
+    });
+
+    await fs.writeFile(agentPath, content);
+    return { type: orm, path: agentPath };
+  }
+
+  /**
+   * Generate database-specific agent
+   */
+  async generateDatabaseAgent(database) {
+    const agentPath = path.join(this.agentsDir, `${database}-agent.md`);
+    const template = await this.loadTemplate('tech-agent.template.md');
+
+    if (!template) return null;
+
+    const samples = await this.extractDatabaseSamples(database);
+
+    const content = TemplateEngine.render(template, {
+      tech: database,
+      techType: 'database',
+      language: this.analysis.primaryLanguage || 'javascript',
+      framework: this.analysis.primaryFramework || 'custom',
+      patterns: samples.patterns,
+      conventions: samples.conventions,
+      samples: samples.code,
+      generated_at: new Date().toISOString(),
+    });
+
+    await fs.writeFile(agentPath, content);
+    return { type: database, path: agentPath };
+  }
+
+  /**
+   * Extract code patterns for a specific agent type
+   */
+  async extractPatterns(agentType) {
+    const patterns = {
+      code: [],
+      conventions: [],
+      samples: [],
+    };
+
+    // Define patterns for each agent type
+    const agentPatterns = {
+      backend: {
+        directories: ['src/repositories', 'src/services', 'src/controllers', 'src/routes', 'api'],
+        keywords: ['repository', 'service', 'controller', 'route', 'handler'],
+      },
+      frontend: {
+        directories: ['src/components', 'src/pages', 'src/app', 'components', 'pages'],
+        keywords: ['component', 'hook', 'page', 'view'],
+      },
+      tester: {
+        directories: ['tests', 'test', '__tests__', '__tests__', 'spec'],
+        keywords: ['describe', 'test', 'it', 'expect', 'mock'],
+      },
+      reviewer: {
+        directories: ['src'],
+        keywords: ['export', 'function', 'class', 'interface'],
+      },
+      fixer: {
+        directories: ['src'],
+        keywords: ['error', 'bug', 'fix', 'throw'],
+      },
+    };
+
+    const config = agentPatterns[agentType];
+    if (!config) return patterns;
+
+    // Scan directories for patterns
+    for (const dir of config.directories) {
+      const dirPath = path.join(this.projectPath, dir);
+      try {
+        const files = await this.scanDirectory(dirPath, 10); // Sample up to 10 files
+
+        for (const file of files) {
+          const content = await fs.readFile(file, 'utf-8');
+          const relativePath = path.relative(this.projectPath, file);
+
+          // Extract code samples
+          if (content.length > 0 && content.length < 2000) {
+            patterns.samples.push({
+              path: relativePath,
+              content: content,
+            });
+          }
+
+          // Identify patterns
+          for (const keyword of config.keywords) {
+            if (content.toLowerCase().includes(keyword)) {
+              patterns.code.push({
+                keyword,
+                context: this.extractContext(content, keyword),
+              });
+            }
+          }
+        }
+      } catch (error) {
+        // Directory doesn't exist, skip
+      }
+    }
+
+    // Detect naming conventions
+    patterns.conventions = await this.detectConventions(agentType);
+
+    return patterns;
+  }
+
+  /**
+   * Extract domain-specific code samples
+   */
+  async extractDomainSamples(domain) {
+    const samples = {
+      code: [],
+      patterns: [],
+      endpoints: [],
+      models: [],
+    };
+
+    // Find domain-specific files
+    const domainPatterns = {
+      'auth-agent': ['auth', 'user', 'login', 'register', 'session', 'token'],
+      'billing-agent': ['billing', 'payment', 'subscription', 'invoice', 'stripe'],
+      'content-agent': ['content', 'post', 'article', 'blog', 'page'],
+      'notification-agent': ['notification', 'email', 'sms', 'push'],
+    };
+
+    const keywords = domainPatterns[domain.name] || [domain.name];
+
+    // Scan for domain files
+    const files = await this.findFilesByKeywords(keywords, 5);
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const relativePath = path.relative(this.projectPath, file);
+
+      samples.code.push({
+        path: relativePath,
+        content: content.substring(0, 1500), // Limit size
+      });
+
+      // Extract API endpoints
+      if (content.includes('router.') || content.includes('app.') || content.includes('@Get')) {
+        samples.endpoints.push(...this.extractEndpoints(content, relativePath));
+      }
+
+      // Extract data models
+      if (content.includes('model') || content.includes('schema') || content.includes('interface')) {
+        samples.models.push(...this.extractModels(content, relativePath));
+      }
+    }
+
+    return samples;
+  }
+
+  /**
+   * Extract framework-specific samples
+   */
+  async extractFrameworkSamples(framework) {
+    const samples = {
+      code: [],
+      patterns: [],
+      conventions: [],
+    };
+
+    const frameworkPatterns = {
+      nextjs: ['app/', 'pages/', 'middleware.ts', 'next.config'],
+      nuxt: ['pages/', 'components/', 'nuxt.config'],
+      remix: ['routes/', 'app/routes/', 'loader', 'action'],
+    };
+
+    const patterns = frameworkPatterns[framework] || [];
+
+    for (const pattern of patterns) {
+      const files = await this.findFilesByPattern(pattern, 3);
+
+      for (const file of files) {
+        const content = await fs.readFile(file, 'utf-8');
+        const relativePath = path.relative(this.projectPath, file);
+
+        samples.code.push({
+          path: relativePath,
+          content: content.substring(0, 1000),
+        });
+      }
+    }
+
+    return samples;
+  }
+
+  /**
+   * Extract ORM-specific samples
+   */
+  async extractORMSamples(orm) {
+    const samples = {
+      code: [],
+      patterns: [],
+      conventions: [],
+    };
+
+    const ormFiles = {
+      prisma: ['schema.prisma', 'client.ts'],
+      drizzle: ['schema.ts', 'db.ts'],
+      typeorm: ['entity.ts', 'repository.ts'],
+      mongoose: ['model.ts', 'schema.ts'],
+    };
+
+    const files = ormFiles[orm] || [];
+
+    for (const file of files) {
+      const foundFiles = await this.findFilesByPattern(file, 2);
+
+      for (const foundFile of foundFiles) {
+        const content = await fs.readFile(foundFile, 'utf-8');
+        const relativePath = path.relative(this.projectPath, foundFile);
+
+        samples.code.push({
+          path: relativePath,
+          content: content.substring(0, 1000),
+        });
+      }
+    }
+
+    return samples;
+  }
+
+  /**
+   * Extract database-specific samples
+   */
+  async extractDatabaseSamples(database) {
+    const samples = {
+      code: [],
+      patterns: [],
+      conventions: [],
+    };
+
+    // Look for migration files, SQL files, etc.
+    const patterns = ['migrations/', '*.sql', 'schema.sql', 'seeds/'];
+
+    for (const pattern of patterns) {
+      const files = await this.findFilesByPattern(pattern, 3);
+
+      for (const file of files) {
+        const content = await fs.readFile(file, 'utf-8');
+        const relativePath = path.relative(this.projectPath, file);
+
+        samples.code.push({
+          path: relativePath,
+          content: content.substring(0, 1000),
+        });
+      }
+    }
+
+    return samples;
+  }
+
+  /**
+   * Scan directory for files
+   */
+  async scanDirectory(dirPath, maxFiles = 10) {
+    const files = [];
+
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (files.length >= maxFiles) break;
+
+        const fullPath = path.join(dirPath, entry.name);
+
+        if (entry.isDirectory()) {
+          const subFiles = await this.scanDirectory(fullPath, maxFiles - files.length);
+          files.push(...subFiles);
+        } else if (entry.isFile() && this.isSourceFile(entry.name)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // Directory doesn't exist or can't be read
+    }
+
+    return files;
+  }
+
+  /**
+   * Find files by keywords in name
+   */
+  async findFilesByKeywords(keywords, maxFiles = 5) {
+    const allFiles = [];
+
+    for (const keyword of keywords) {
+      const files = await this.findFilesByPattern(keyword, maxFiles);
+      allFiles.push(...files);
+    }
+
+    return allFiles.slice(0, maxFiles);
+  }
+
+  /**
+   * Find files by pattern
+   */
+  async findFilesByPattern(pattern, maxFiles = 5) {
+    const files = [];
+
+    const scanDir = async (dirPath) => {
+      try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+        for (const entry of entries) {
+          if (files.length >= maxFiles) return;
+
+          const fullPath = path.join(dirPath, entry.name);
+
+          if (entry.isDirectory()) {
+            // Skip node_modules and similar
+            if (!['node_modules', '.git', 'dist', 'build'].includes(entry.name)) {
+              await scanDir(fullPath);
+            }
+          } else if (entry.isFile()) {
+            if (entry.name.toLowerCase().includes(pattern.toLowerCase()) ||
+                fullPath.toLowerCase().includes(pattern.toLowerCase())) {
+              files.push(fullPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Can't read directory
+      }
+    };
+
+    await scanDir(this.projectPath);
+    return files;
+  }
+
+  /**
+   * Check if file is a source file
+   */
+  isSourceFile(filename) {
+    const extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.go', '.rs'];
+    return extensions.some(ext => filename.endsWith(ext));
+  }
+
+  /**
+   * Extract context around a keyword
+   */
+  extractContext(content, keyword) {
+    const lines = content.split('\n');
+    const context = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].toLowerCase().includes(keyword.toLowerCase())) {
+        const start = Math.max(0, i - 2);
+        const end = Math.min(lines.length, i + 3);
+        context.push(lines.slice(start, end).join('\n'));
+      }
+    }
+
+    return context.slice(0, 3); // Max 3 contexts
+  }
+
+  /**
+   * Detect naming conventions
+   */
+  async detectConventions(agentType) {
+    const conventions = [];
+
+    // Sample some files to detect conventions
+    const files = await this.findFilesByPattern('.ts', 5);
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+
+      // Detect import style
+      if (content.includes('@/')) {
+        conventions.push('Uses @ alias for imports');
+      }
+
+      // Detect naming patterns
+      if (content.match(/class \w+/)) {
+        conventions.push('Uses class-based components');
+      }
+
+      if (content.match(/export (const|function) \w+/)) {
+        conventions.push('Uses functional exports');
+      }
+    }
+
+    return [...new Set(conventions)]; // Deduplicate
+  }
+
+  /**
+   * Extract API endpoints from code
+   */
+  extractEndpoints(content, filePath) {
+    const endpoints = [];
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      if (line.includes('router.') || line.includes('app.')) {
+        endpoints.push({
+          file: filePath,
+          code: line.trim(),
+        });
+      }
+    }
+
+    return endpoints.slice(0, 5);
+  }
+
+  /**
+   * Extract data models from code
+   */
+  extractModels(content, filePath) {
+    const models = [];
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      if (line.includes('model ') || line.includes('schema ') || line.includes('interface ')) {
+        models.push({
+          file: filePath,
+          code: line.trim(),
+        });
+      }
+    }
+
+    return models.slice(0, 5);
+  }
+
+  /**
+   * Load template file
+   */
+  async loadTemplate(templateName) {
+    const templatePath = path.join(this.templatesDir, templateName);
+
+    try {
+      return await fs.readFile(templatePath, 'utf-8');
+    } catch (error) {
+      console.warn(`Template not found: ${templateName}`);
+      return null;
+    }
+  }
+
+  /**
+   * Update architecture.json with agent info
+   */
+  async updateArchitectureConfig(agents) {
+    const configPath = path.join(this.projectPath, '.agentful/architecture.json');
+
+    let config = {};
+
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      config = JSON.parse(content);
+    } catch (error) {
+      // Config doesn't exist yet
+    }
+
+    config.agents = {
+      generated: {
+        core: agents.core.map(a => a.type),
+        domains: agents.domains.map(a => a.type),
+        tech: agents.tech.map(a => a.type),
+      },
+      generatedAt: new Date().toISOString(),
+    };
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+}
+
+export default AgentGenerator;