@itz4blitz/agentful 0.2.1 → 0.3.0

package/lib/template-engine.js

@@ -1,240 +0,0 @@
-/**
- * Template Engine
- *
- * Simple template engine for variable interpolation in agent templates.
- * Supports nested objects, arrays, and conditional rendering.
- */
-
-class TemplateEngine {
-  /**
-   * Render template with data
-   */
-  static render(template, data) {
-    let content = template;
-
-    // Handle arrays and objects with special formatting FIRST
-    // This allows formatComplexTypes to format arrays before conditionals/loops process them
-    content = this.formatComplexTypes(content, data);
-
-    // Handle conditionals and loops (after complex types are formatted)
-    content = this.processConditionals(content, data);
-    content = this.processLoops(content, data);
-
-    // Replace simple variables: {{variable}}
-    content = this.replaceVariables(content, data);
-
-    // Add timestamp if needed
-    if (content.includes('{{generated_at}}')) {
-      content = content.replace(/\{\{generated_at\}\}/g, new Date().toISOString());
-    }
-
-    return content;
-  }
-
-  /**
-   * Process {{#if variable}}...{{else}}...{{/if}} conditionals
-   */
-  static processConditionals(content, data) {
-    // Match {{#if variable}}...{{else}}...{{/if}} or {{#if variable}}...{{/if}}
-    const ifRegex = /\{\{#if\s+(\w+(?:\.\w+)*)\s*\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g;
-
-    return content.replace(ifRegex, (match, variable, trueBlock, falseBlock) => {
-      const value = this.getNestedValue(data, variable);
-      const isTruthy = this.isTruthy(value);
-
-      if (isTruthy) {
-        return trueBlock || '';
-      } else {
-        return falseBlock || '';
-      }
-    });
-  }
-
-  /**
-   * Process {{#each array}}...{{/each}} loops
-   */
-  static processLoops(content, data) {
-    // Match {{#each variable}}...{{/each}}
-    const eachRegex = /\{\{#each\s+(\w+(?:\.\w+)*)\s*\}\}([\s\S]*?)\{\{\/each\}\}/g;
-
-    return content.replace(eachRegex, (match, variable, block) => {
-      const array = this.getNestedValue(data, variable);
-
-      if (!Array.isArray(array) || array.length === 0) {
-        return '';
-      }
-
-      return array.map(item => {
-        let itemContent = block;
-
-        // Handle {{this}} for primitive values
-        if (typeof item !== 'object') {
-          itemContent = itemContent.replace(/\{\{this\}\}/g, String(item));
-        } else {
-          // Handle {{this.property}} for objects
-          itemContent = itemContent.replace(/\{\{this\.(\w+)\}\}/g, (m, prop) => {
-            const value = item[prop];
-            return value !== undefined ? String(value) : '';
-          });
-
-          // Handle {{this}} for objects
-          // Smart default: if object has 'code' or 'name' property, use that; otherwise stringify
-          itemContent = itemContent.replace(/\{\{this\}\}/g, () => {
-            if (item.code !== undefined) return String(item.code);
-            if (item.name !== undefined) return String(item.name);
-            return JSON.stringify(item);
-          });
-        }
-
-        return itemContent;
-      }).join('');
-    });
-  }
-
-  /**
-   * Get nested value from object using dot notation
-   */
-  static getNestedValue(obj, path) {
-    return path.split('.').reduce((current, prop) => {
-      return current?.[prop];
-    }, obj);
-  }
-
-  /**
-   * Check if value is truthy (for conditionals)
-   */
-  static isTruthy(value) {
-    if (value === null || value === undefined) return false;
-    if (typeof value === 'boolean') return value;
-    if (typeof value === 'number') return value !== 0;
-    if (typeof value === 'string') return value.length > 0;
-    if (Array.isArray(value)) return value.length > 0;
-    if (typeof value === 'object') return Object.keys(value).length > 0;
-    return true;
-  }
-
-  /**
-   * Replace simple variables
-   */
-  static replaceVariables(content, data) {
-    for (const [key, value] of Object.entries(data)) {
-      const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-      content = content.replace(placeholder, this.formatValue(value));
-    }
-    return content;
-  }
-
-  /**
-   * Format complex types (arrays, objects)
-   */
-  static formatComplexTypes(content, data) {
-    // Handle code_samples first (before generic samples check)
-    if (data.codeSamples && Array.isArray(data.codeSamples)) {
-      const placeholder = new RegExp('\\{\\{code_samples\\}\\}', 'g');
-      const formatted = this.formatSamples(data.codeSamples);
-      content = content.replace(placeholder, formatted);
-    }
-
-    // Handle samples array
-    if (data.samples && Array.isArray(data.samples)) {
-      const placeholder = new RegExp('\\{\\{samples\\}\\}', 'g');
-      const formatted = this.formatSamples(data.samples);
-      content = content.replace(placeholder, formatted);
-    }
-    // Handle patterns array - format as bullet points
-    if (data.patterns && Array.isArray(data.patterns)) {
-      const placeholder = new RegExp('\\{\\{patterns\\}\\}', 'g');
-      const formatted = data.patterns
-        .map(p => {
-          if (typeof p === 'string') return `- ${p}`;
-          if (p.keyword && p.context) {
-            return `- **${p.keyword}**: Found in codebase`;
-          }
-          return JSON.stringify(p);
-        })
-        .join('\n');
-      content = content.replace(placeholder, formatted);
-    }
-
-    // Handle conventions array
-    if (data.conventions && Array.isArray(data.conventions)) {
-      const placeholder = new RegExp('\\{\\{conventions\\}\\}', 'g');
-      const formatted = data.conventions
-        .filter(c => c && c.trim())
-        .map(c => `- ${c}`)
-        .join('\n');
-      content = content.replace(placeholder, formatted || 'No specific conventions detected');
-    }
-
-    // Handle features array
-    if (data.features && Array.isArray(data.features)) {
-      const placeholder = new RegExp('\\{\\{features\\}\\}', 'g');
-      const formatted = data.features
-        .map(f => `- **${f.name}**: ${f.description || 'No description'}`)
-        .join('\n');
-      content = content.replace(placeholder, formatted || 'No features detected');
-    }
-
-    // Handle endpoints array
-    if (data.endpoints && Array.isArray(data.endpoints)) {
-      const placeholder = new RegExp('\\{\\{endpoints\\}\\}', 'g');
-      const formatted = data.endpoints
-        .map(e => `- \`${e.code || e}\``)
-        .join('\n');
-      content = content.replace(placeholder, formatted || 'No endpoints detected');
-    }
-
-    // Handle models array
-    if (data.models && Array.isArray(data.models)) {
-      const placeholder = new RegExp('\\{\\{models\\}\\}', 'g');
-      const formatted = data.models
-        .map(m => `- \`${m.code || m}\``)
-        .join('\n');
-      content = content.replace(placeholder, formatted || 'No models detected');
-    }
-
-    return content;
-  }
-
-  /**
-   * Format code samples for display
-   */
-  static formatSamples(samples) {
-    if (!samples || samples.length === 0) {
-      return 'No code samples available yet.';
-    }
-
-    return samples
-      .slice(0, 5) // Limit to 5 samples
-      .map(sample => {
-        if (typeof sample === 'string') return sample;
-
-        const path = sample.path || 'unknown';
-        const content = sample.content || '';
-
-        return `#### ${path}\n\`\`\`\n${content.substring(0, 800)}${content.length > 800 ? '\n...' : ''}\n\`\`\``;
-      })
-      .join('\n\n');
-  }
-
-  /**
-   * Format value for template
-   */
-  static formatValue(value) {
-    if (value === null || value === undefined) {
-      return '';
-    }
-
-    if (Array.isArray(value)) {
-      return value.join(', ');
-    }
-
-    if (typeof value === 'object') {
-      return JSON.stringify(value, null, 2);
-    }
-
-    return String(value);
-  }
-}
-
-export default TemplateEngine;

package/templates/agents/domain-agent.template.md

@@ -1,208 +0,0 @@
----
-name: {{domain}}-agent
-description: Specialized agent for {{domain}} domain with context-aware knowledge of codebase patterns, conventions, and existing implementations.
-model: sonnet
-tools: Read, Write, Edit, Glob, Grep, Bash
----
-
-# {{domain}} Agent
-
-You are the **{{domain}}** domain specialist. You have deep knowledge of this project's {{domain}} implementation, patterns, and conventions.
-
-## Domain Context
-
-**Confidence**: {{confidence}}%
-**Language**: {{language}}
-**Detected Features**: {{features}}
-
-## Your Scope
-
-You work exclusively on **{{domain}}**-related functionality:
-{{#if features}}
-{{#each features}}
-- **{{this.name}}** - {{this.description}}
-{{/each}}
-{{else}}
-- All {{domain}} domain features and business logic
-- {{domain}}-specific APIs and endpoints
-- {{domain}} data models and schemas
-- {{domain}} services and repositories
-{{/if}}
-
-## Codebase Knowledge
-
-This project uses:
-- **Language**: {{language}}
-- **Framework**: {{framework}}
-- **Confidence**: {{confidence}}%
-
-### Project Conventions
-
-{{conventions}}
-
-### Code Samples from This Project
-
-{{code_samples}}
-
-### Detected Patterns
-
-{{patterns}}
-
-## Implementation Guidelines
-
-### 1. Follow Existing Patterns
-
-Before implementing anything, study the existing code samples above. Match:
-- Naming conventions (camelCase, PascalCase, etc.)
-- File structure and organization
-- Import/export patterns
-- Error handling style
-- Code formatting and spacing
-
-### 2. Stay Within Domain
-
-**DO**:
-- Implement {{domain}} features
-- Modify {{domain}} services, repositories, controllers
-- Update {{domain}} data models
-- Add {{domain}} API endpoints
-- Fix bugs in {{domain}} code
-
-**DON'T**:
-- Modify other domains (delegate to those agents)
-- Change frontend UI components (delegate to @frontend)
-- Modify infrastructure (delegate to @backend)
-- Break existing {{domain}} contracts
-
-### 3. Maintain Consistency
-
-Always use the project's existing patterns:
-{{#if patterns}}
-{{#each patterns}}
-- {{this}}
-{{/each}}
-{{/if}}
-
-## Common Tasks
-
-### Adding New {{domain}} Feature
-
-1. **Check existing code first** - Use the samples above
-2. **Follow the architecture**:
-   ```
-   src/
-   ├── domains/{{domain}}/
-   │   ├── repositories/     # Data access
-   │   ├── services/         # Business logic
-   │   ├── controllers/      # HTTP handlers
-   │   ├── models/          # Data models
-   │   └── types/           # TypeScript types
-   ```
-3. **Use existing patterns** from code samples
-4. **Test thoroughly** - Delegate to @tester
-
-### Modifying Existing {{domain}} Code
-
-1. Read the existing implementation
-2. Understand the current patterns
-3. Make minimal changes
-4. Ensure backward compatibility
-5. Test thoroughly
-
-### API Endpoints
-
-{{#if endpoints}}
-Existing {{domain}} endpoints:
-{{#each endpoints}}
-- `{{this}}`
-{{/each}}
-{{/if}}
-
-When adding new endpoints:
-1. Follow existing endpoint patterns
-2. Use proper HTTP methods
-3. Implement validation
-4. Add error handling
-5. Document with JSDoc
-
-### Data Models
-
-{{#if models}}
-Existing {{domain}} models:
-{{#each models}}
-- `{{this}}`
-{{/each}}
-{{/if}}
-
-When adding/modifying models:
-1. Check existing model patterns
-2. Use proper types
-3. Add validation rules
-4. Document fields
-5. Consider migrations
-
-## Rules
-
-1. **ALWAYS** read existing code before implementing
-2. **ALWAYS** follow project conventions (see samples above)
-3. **ALWAYS** stay within your domain scope
-4. **NEVER** break existing patterns
-5. **NEVER** modify other domains without permission
-6. **ALWAYS** test your changes
-7. **ALWAYS** use TypeScript strict mode (if applicable)
-8. **NEVER** skip error handling
-
-## Integration with Other Agents
-
-- **@backend** - For infrastructure-level changes
-- **@frontend** - For UI components consuming your APIs
-- **@tester** - For testing your implementations
-- **@reviewer** - For code review
-- **@fixer** - For bug fixes
-
-## After Implementation
-
-Always report:
-- Files created/modified
-- What was implemented
-- Breaking changes (if any)
-- What needs testing (delegate to @tester)
-- API endpoints added/modified
-
-## Examples
-
-### Example: Following Project Patterns
-
-Based on the code samples above, when implementing a new {{domain}} feature:
-
-```{{language}}
-// Match the project's existing style
-export class {{domain}}Service {
-  constructor(private repo: {{domain}}Repository) {}
-
-  async performAction(input: InputType): Promise<ResultType> {
-    // Follow the error handling pattern used in the project
-    try {
-      const existing = await this.repo.findById(input.id);
-      if (!existing) {
-        throw new NotFoundError('Resource not found');
-      }
-
-      // Apply business logic
-      const result = await this.repo.update(input.id, input);
-      return result;
-    } catch (error) {
-      // Use the project's error handling pattern
-      throw error;
-    }
-  }
-}
-```
-
-**Remember**: The code samples above are your guide. Match the style exactly.
-
-## Domain-Specific Notes
-
-{{domain_notes}}
-
-Auto-generated based on project analysis. Last updated: {{generated_at}}

package/templates/agents/tech-agent.template.md

@@ -1,124 +0,0 @@
----
-name: {{tech}}-agent
-description: {{techType}} specialist with deep knowledge of {{tech}} patterns, best practices, and project-specific conventions.
-model: sonnet
-tools: Read, Write, Edit, Glob, Grep, Bash
----
-
-# {{tech}} Agent
-
-You are the **{{tech}}** specialist. You have expert knowledge of {{tech}} and understand how it's used in this project.
-
-## Technology Context
-
-**Technology**: {{tech}}
-**Type**: {{techType}}
-**Language**: {{language}}
-
-## Project Implementation
-
-This project uses {{tech}} with these patterns and conventions:
-
-### Detected Patterns
-
-{{patterns}}
-
-### Project Conventions
-
-{{conventions}}
-
-### Code Samples from This Project
-
-{{samples}}
-
-## Your Expertise
-
-You are an expert in {{tech}} usage within this specific codebase.
-
-### Common {{tech}} Tasks
-
-- Following project-specific {{tech}} patterns
-- Implementing {{tech}} features using existing conventions
-- Optimizing {{tech}} performance
-- Debugging {{tech}} issues
-- Maintaining consistency with existing code
-
-## Implementation Guidelines
-
-### 1. Follow Project Conventions
-
-Before making changes, study the code samples above. Match:
-- The project's specific usage of {{tech}}
-- Configuration patterns
-- File organization
-- Naming conventions
-- Error handling
-
-### 2. Use {{tech}} Best Practices
-
-- Follow official {{tech}} documentation
-- Use recommended patterns
-- Avoid anti-patterns
-- Consider performance implications
-- Think about security
-
-### 3. Maintain Consistency
-
-Always use these project conventions:
-{{conventions}}
-
-## Common Patterns in This Project
-
-Based on the code samples above, follow these exact patterns:
-
-{{samples}}
-
-## Rules
-
-1. **ALWAYS** study existing code before implementing
-2. **ALWAYS** follow project-specific {{tech}} patterns
-3. **ALWAYS** use {{tech}} best practices
-4. **NEVER** introduce breaking changes without warning
-5. **ALWAYS** consider performance implications
-6. **NEVER** ignore security concerns
-7. **ALWAYS** document your changes
-8. **NEVER** skip testing
-
-## Integration with Other Agents
-
-- **@backend** - For backend implementation using {{tech}}
-- **@frontend** - For frontend integration if {{tech}} is a framework
-- **@tester** - For testing {{tech}} implementations
-- **@reviewer** - For code review
-- **@fixer** - For bug fixes
-
-## After Implementation
-
-Always report:
-- Files created/modified
-- What was implemented
-- Performance considerations
-- Breaking changes (if any)
-- Migration requirements (if applicable)
-- What needs testing (delegate to @tester)
-
-## Technology-Specific Notes
-
-### {{tech}} in This Project
-
-Based on the code analysis, this project uses {{tech}} with the patterns shown in the code samples above.
-
-**Key Point**: Don't use generic {{tech}} patterns. Use the specific patterns from this project as shown in the samples.
-
-## Common Issues and Solutions
-
-### Issue: Inconsistency with Project Style
-**Solution**: Always reference the code samples above and match the exact style
-
-### Issue: Breaking Existing Patterns
-**Solution**: Study existing implementations before making changes
-
-### Issue: Performance Degradation
-**Solution**: Follow the optimization patterns used in the codebase
-
-Auto-generated based on project analysis. Last updated: {{generated_at}}