@itz4blitz/agentful 0.2.0 → 0.2.1

package/.claude/product/README.md

@@ -301,6 +301,38 @@ For hierarchical structure examples, check:
 
 **No**: The system auto-detects ONE format. Choose the format that best fits your project size and complexity.
 
+## Product Analysis File
+
+After running `/agentful-product`, a `product-analysis.json` file is generated:
+
+```bash
+.claude/product/
+├── index.md                    # Your product spec (template)
+└── product-analysis.json       # Generated analysis (created by /agentful-product)
+```
+
+**Key points:**
+- **Not in templates**: This file doesn't exist in the agentful package itself
+- **Generated on demand**: Created when you run `/agentful-product` in your project
+- **Purpose**: Analyzes your product spec for completeness, clarity, feasibility, testability, and consistency
+- **Scores readiness**: 0-100% score with blocking issues and recommendations
+- **Version controlled**: Commit to git to track spec quality improvements over time
+
+**Example content:**
+```json
+{
+  "version": "1.0",
+  "timestamp": "2026-01-20T00:00:00Z",
+  "readiness_score": 75,
+  "dimensions": {
+    "completeness": { "score": 85 },
+    "clarity": { "score": 90 }
+  },
+  "blocking_issues": [],
+  "can_start_development": true
+}
+```
+
 ## Summary
 
 | Format | Best For | Tracking | File Structure |

package/bin/cli.js

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'url';
 import { analyzeProject, exportToArchitectureJson } from '../lib/project-analyzer.js';
 import AgentGenerator from '../lib/agent-generator.js';
 import DomainStructureGenerator from '../lib/domain-structure-generator.js';
+import { detectTechStack } from '../lib/tech-stack-detector.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -582,87 +583,13 @@ function showStatus() {
   console.log('');
 }
 
-function detectTechStack() {
-  const targetDir = process.cwd();
-  const detected = {
-    language: null,
-    framework: null,
-    dependencies: [],
-    devDependencies: []
-  };
-
-  // Check for package.json (Node.js/JavaScript/TypeScript)
-  const packageJsonPath = path.join(targetDir, 'package.json');
-  if (fs.existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-      detected.dependencies = Object.keys(pkg.dependencies || {});
-      detected.devDependencies = Object.keys(pkg.devDependencies || {});
-      detected.language = pkg.type === 'module' ? 'TypeScript/ESM' : 'JavaScript/TypeScript';
-
-      // Detect framework
-      if (detected.dependencies.includes('next')) {
-        detected.framework = 'Next.js';
-      } else if (detected.dependencies.includes('react')) {
-        detected.framework = 'React';
-      } else if (detected.dependencies.includes('vue')) {
-        detected.framework = 'Vue';
-      } else if (detected.dependencies.includes('express')) {
-        detected.framework = 'Express';
-      } else if (detected.dependencies.includes('nestjs')) {
-        detected.framework = 'NestJS';
-      }
-    } catch (err) {
-      log(colors.yellow, '⚠️  Could not parse package.json');
-    }
-  }
-
-  // Check for requirements.txt or pyproject.toml (Python)
-  const requirementsPath = path.join(targetDir, 'requirements.txt');
-  const pyprojectPath = path.join(targetDir, 'pyproject.toml');
-  if (fs.existsSync(requirementsPath) || fs.existsSync(pyprojectPath)) {
-    detected.language = 'Python';
-    const requirements = fs.existsSync(requirementsPath)
-      ? fs.readFileSync(requirementsPath, 'utf-8')
-      : '';
-    if (requirements.includes('django')) detected.framework = 'Django';
-    else if (requirements.includes('flask')) detected.framework = 'Flask';
-    else if (requirements.includes('fastapi')) detected.framework = 'FastAPI';
-  }
-
-  // Check for go.mod (Go)
-  if (fs.existsSync(path.join(targetDir, 'go.mod'))) {
-    detected.language = 'Go';
-    detected.framework = 'Standard Library';
-  }
-
-  // Check for Cargo.toml (Rust)
-  if (fs.existsSync(path.join(targetDir, 'Cargo.toml'))) {
-    detected.language = 'Rust';
-  }
-
-  // Check for .csproj or .fsproj (C#/.NET)
-  const csprojFiles = fs.readdirSync(targetDir).filter(f => f.endsWith('.csproj'));
-  if (csprojFiles.length > 0) {
-    detected.language = 'C#';
-    detected.framework = 'ASP.NET';
-  }
-
-  // Check for pom.xml (Java)
-  if (fs.existsSync(path.join(targetDir, 'pom.xml'))) {
-    detected.language = 'Java';
-    detected.framework = 'Maven';
-  }
-
-  return detected;
-}
-
 function generateAgentPrompt(stack) {
   let prompt = `# Tech Stack Analysis\n\n`;
   prompt += `**Language**: ${stack.language || 'Unknown'}\n`;
-  prompt += `**Framework**: ${stack.framework || 'None'}\n\n`;
+  const primaryFramework = stack.frameworks && stack.frameworks.length > 0 ? stack.frameworks[0] : null;
+  prompt += `**Framework**: ${primaryFramework || 'None'}\n\n`;
 
-  if (stack.dependencies.length > 0) {
+  if (stack.dependencies && stack.dependencies.length > 0) {
     prompt += `**Key Dependencies**:\n`;
     stack.dependencies.slice(0, 10).forEach(dep => {
       prompt += `- ${dep}\n`;
@@ -724,11 +651,11 @@ async function generateAgents() {
     process.exit(1);
   }
 
-  // Detect tech stack
+  // Detect tech stack using library function
   log(colors.dim, 'Analyzing tech stack...');
-  const stack = detectTechStack();
+  const stack = await detectTechStack(process.cwd());
 
-  if (!stack.language) {
+  if (!stack.language || stack.language === 'unknown') {
     log(colors.yellow, '⚠️  Could not detect language/framework');
     log(colors.dim, 'Supported: Node.js, Python, Go, Rust, C#, Java');
     console.log('');
@@ -739,7 +666,8 @@ async function generateAgents() {
     return;
   }
 
-  log(colors.green, `✓ Detected: ${stack.language} ${stack.framework ? `(${stack.framework})` : ''}`);
+  const primaryFramework = stack.frameworks.length > 0 ? stack.frameworks[0] : null;
+  log(colors.green, `✓ Detected: ${stack.language} ${primaryFramework ? `(${primaryFramework})` : ''}`);
   log(colors.dim, `   Dependencies: ${stack.dependencies.length} packages`);
 
   // Update architecture.json
@@ -762,7 +690,7 @@ async function generateAgents() {
 
   log(colors.bright, 'Detected Stack:');
   if (stack.language) log(colors.cyan, `  Language:    ${stack.language}`);
-  if (stack.framework) log(colors.cyan, `  Framework:   ${stack.framework}`);
+  if (primaryFramework) log(colors.cyan, `  Framework:   ${primaryFramework}`);
   if (stack.dependencies.length > 0) {
     log(colors.cyan, `  Dependencies: ${stack.dependencies.length} packages`);
   }

package/lib/agent-generator.js

@@ -13,12 +13,124 @@ import TemplateEngine from './template-engine.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+/**
+ * Default core agent types registry
+ * Users can extend this by passing custom agent types to the constructor
+ */
+const DEFAULT_CORE_AGENT_TYPES = ['backend', 'frontend', 'tester', 'reviewer', 'fixer'];
+
+/**
+ * Default agent patterns configuration
+ * Defines how each agent type should extract patterns from the codebase
+ */
+const DEFAULT_AGENT_PATTERNS = {
+  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'],
+  },
+};
+
 class AgentGenerator {
-  constructor(projectPath, analysis) {
+  /**
+   * @param {string} projectPath - Path to the project
+   * @param {object} analysis - Project analysis results
+   * @param {object} options - Configuration options
+   * @param {string[]} options.customAgentTypes - Additional core agent types to generate
+   * @param {object} options.customAgentPatterns - Pattern configurations for custom agent types
+   */
+  constructor(projectPath, analysis, options = {}) {
     this.projectPath = projectPath;
     this.analysis = analysis;
     this.templatesDir = path.join(__dirname, '../templates/agents');
     this.agentsDir = path.join(projectPath, '.claude/agents/auto-generated');
+
+    // Extensible agent type registry
+    this.coreAgentTypes = [...DEFAULT_CORE_AGENT_TYPES];
+    this.agentPatterns = { ...DEFAULT_AGENT_PATTERNS };
+
+    // Apply custom agent types if provided
+    if (options.customAgentTypes && Array.isArray(options.customAgentTypes)) {
+      this.coreAgentTypes.push(...options.customAgentTypes);
+    }
+
+    // Apply custom agent patterns if provided
+    if (options.customAgentPatterns && typeof options.customAgentPatterns === 'object') {
+      Object.assign(this.agentPatterns, options.customAgentPatterns);
+    }
+  }
+
+  /**
+   * Register a custom agent type at runtime
+   * @param {string} type - Agent type name
+   * @param {object} pattern - Pattern configuration for the agent type
+   * @param {string[]} pattern.directories - Directories to scan for this agent type
+   * @param {string[]} pattern.keywords - Keywords to look for in code
+   */
+  registerAgentType(type, pattern) {
+    if (!this.coreAgentTypes.includes(type)) {
+      this.coreAgentTypes.push(type);
+    }
+
+    if (pattern) {
+      this.agentPatterns[type] = pattern;
+    }
+  }
+
+  /**
+   * Get all registered core agent types
+   * @returns {string[]} List of core agent types
+   */
+  getCoreAgentTypes() {
+    return [...this.coreAgentTypes];
+  }
+
+  /**
+   * Get pattern configuration for a specific agent type
+   * @param {string} type - Agent type name
+   * @returns {object|null} Pattern configuration or null if not found
+   */
+  getAgentPattern(type) {
+    return this.agentPatterns[type] || null;
+  }
+
+  /**
+   * Load custom agent types from a configuration file
+   * @param {string} configPath - Path to the configuration file (JSON)
+   * @returns {Promise<void>}
+   */
+  async loadCustomAgentTypesFromConfig(configPath) {
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      const config = JSON.parse(content);
+
+      if (config.customAgentTypes && Array.isArray(config.customAgentTypes)) {
+        for (const agentConfig of config.customAgentTypes) {
+          if (agentConfig.type && agentConfig.pattern) {
+            this.registerAgentType(agentConfig.type, agentConfig.pattern);
+          }
+        }
+      }
+
+      console.log(`✅ Loaded custom agent types from ${configPath}`);
+    } catch (error) {
+      console.warn(`⚠️  Could not load custom agent types from ${configPath}: ${error.message}`);
+    }
   }
 
   /**
@@ -59,11 +171,9 @@ class AgentGenerator {
    * Generate core agents (always needed)
    */
   async generateCoreAgents() {
-    const coreAgentTypes = ['backend', 'frontend', 'tester', 'reviewer', 'fixer'];
-
     const agents = [];
 
-    for (const type of coreAgentTypes) {
+    for (const type of this.coreAgentTypes) {
       const agentPath = path.join(this.agentsDir, `${type}.md`);
       const template = await this.loadTemplate(`${type}-agent.template.md`);
 
@@ -254,32 +364,12 @@ class AgentGenerator {
       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;
+    // Get pattern configuration from registry
+    const config = this.agentPatterns[agentType];
+    if (!config) {
+      console.warn(`⚠️  No pattern configuration found for agent type: ${agentType}`);
+      return patterns;
+    }
 
     // Scan directories for patterns
     for (const dir of config.directories) {
@@ -683,3 +773,6 @@ class AgentGenerator {
 }
 
 export default AgentGenerator;
+
+// Export default configurations for use by consumers
+export { DEFAULT_CORE_AGENT_TYPES, DEFAULT_AGENT_PATTERNS };

package/lib/domain-detector.js

@@ -198,9 +198,9 @@ async function analyzeDirectoryStructure(projectRoot) {
           if (dirName.includes(keyword.toLowerCase())) {
             // Exact match gets higher score
             if (dirName === keyword.toLowerCase()) {
-              signals[domain] = Math.min(signals[domain] || 0, 0) + 0.8;
+              signals[domain] = Math.min((signals[domain] || 0) + 0.8, 1.0);
             } else {
-              signals[domain] = Math.min(signals[domain] || 0, 0) + 0.5;
+              signals[domain] = Math.min((signals[domain] || 0) + 0.5, 1.0);
             }
           }
         }
@@ -217,7 +217,7 @@ async function analyzeDirectoryStructure(projectRoot) {
             for (const [domain, pattern] of Object.entries(DOMAIN_PATTERNS)) {
               for (const keyword of pattern.keywords) {
                 if (subDirName.includes(keyword.toLowerCase())) {
-                  signals[domain] = Math.min(signals[domain] || 0, 0) + 0.3;
+                  signals[domain] = Math.min((signals[domain] || 0) + 0.3, 1.0);
                 }
               }
             }
@@ -298,7 +298,7 @@ function analyzeFileForDomains(filePath, signals) {
       for (const keyword of pattern.keywords) {
         // Check filename
         if (fileName.includes(keyword.toLowerCase())) {
-          signals[domain] = Math.min(signals[domain] || 0, 0) + 0.4;
+          signals[domain] = Math.min((signals[domain] || 0) + 0.4, 1.0);
         }
 
         // Check content with regex for word boundaries

package/lib/template-engine.js

@@ -13,8 +13,13 @@ class TemplateEngine {
     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);
 
@@ -26,6 +31,88 @@ class TemplateEngine {
     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
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itz4blitz/agentful",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Human-in-the-loop development kit for Claude Code with smart product analysis and natural conversation",
   "type": "module",
   "bin": {
@@ -10,17 +10,23 @@
     "init": "node bin/cli.js init",
     "release": "semantic-release",
     "release:dry-run": "semantic-release --dry-run",
-    "version": "node -e \"const pkg=require('./package.json'); const v=require('./version.json'); v.version=pkg.version; require('fs').writeFileSync('version.json', JSON.stringify(v, null, 2));\"",
     "docs:dev": "vocs dev",
     "docs:build": "vocs build",
     "docs:preview": "vocs preview"
   },
+  "exports": {
+    ".": {
+      "import": "./lib/index.js"
+    }
+  },
   "files": [
     "bin/",
     "lib/",
     "template/",
+    "templates/",
     ".claude/",
-    "version.json"
+    "version.json",
+    "LICENSE"
   ],
   "keywords": [
     "claude-code",

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

@@ -0,0 +1,208 @@
+---
+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

@@ -0,0 +1,124 @@
+---
+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}}