@ai-coders/context 0.7.0 → 0.7.1

package/dist/generators/shared/structures/agents/definitions.js

@@ -1,22 +1,561 @@
 "use strict";
 /**
- * Agent structure definitions
+ * Agent structure definitions with static default content
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mobileSpecialistStructure = exports.databaseSpecialistStructure = exports.devopsSpecialistStructure = exports.architectSpecialistStructure = exports.frontendSpecialistStructure = exports.backendSpecialistStructure = exports.securityAuditorStructure = exports.performanceOptimizerStructure = exports.documentationWriterStructure = exports.testWriterStructure = exports.refactoringSpecialistStructure = exports.featureDeveloperStructure = exports.bugFixerStructure = exports.codeReviewerStructure = void 0;
 const factory_1 = require("./factory");
-exports.codeReviewerStructure = (0, factory_1.createAgentStructure)('code-reviewer', 'Code Reviewer', 'Reviews code changes for quality, style, and best practices', 'Focus on code quality, maintainability, security issues, and adherence to project conventions.');
-exports.bugFixerStructure = (0, factory_1.createAgentStructure)('bug-fixer', 'Bug Fixer', 'Analyzes bug reports and implements targeted fixes', 'Focus on root cause analysis, minimal side effects, and regression prevention.');
-exports.featureDeveloperStructure = (0, factory_1.createAgentStructure)('feature-developer', 'Feature Developer', 'Implements new features according to specifications', 'Focus on clean architecture, integration with existing code, and comprehensive testing.');
-exports.refactoringSpecialistStructure = (0, factory_1.createAgentStructure)('refactoring-specialist', 'Refactoring Specialist', 'Identifies code smells and improves code structure', 'Focus on incremental changes, test coverage, and preserving functionality.');
-exports.testWriterStructure = (0, factory_1.createAgentStructure)('test-writer', 'Test Writer', 'Writes comprehensive tests and maintains test coverage', 'Focus on unit tests, integration tests, edge cases, and test maintainability.');
-exports.documentationWriterStructure = (0, factory_1.createAgentStructure)('documentation-writer', 'Documentation Writer', 'Creates and maintains documentation', 'Focus on clarity, practical examples, and keeping docs in sync with code.');
-exports.performanceOptimizerStructure = (0, factory_1.createAgentStructure)('performance-optimizer', 'Performance Optimizer', 'Identifies bottlenecks and optimizes performance', 'Focus on measurement, actual bottlenecks, and caching strategies.');
-exports.securityAuditorStructure = (0, factory_1.createAgentStructure)('security-auditor', 'Security Auditor', 'Identifies security vulnerabilities and implements best practices', 'Focus on OWASP top 10, dependency scanning, and principle of least privilege.');
-exports.backendSpecialistStructure = (0, factory_1.createAgentStructure)('backend-specialist', 'Backend Specialist', 'Designs and implements server-side architecture', 'Focus on APIs, microservices, database optimization, and authentication.');
-exports.frontendSpecialistStructure = (0, factory_1.createAgentStructure)('frontend-specialist', 'Frontend Specialist', 'Designs and implements user interfaces', 'Focus on responsive design, accessibility, state management, and performance.');
-exports.architectSpecialistStructure = (0, factory_1.createAgentStructure)('architect-specialist', 'Architect Specialist', 'Designs overall system architecture and patterns', 'Focus on scalability, maintainability, and technical standards.');
-exports.devopsSpecialistStructure = (0, factory_1.createAgentStructure)('devops-specialist', 'DevOps Specialist', 'Designs CI/CD pipelines and infrastructure', 'Focus on automation, infrastructure as code, and monitoring.');
-exports.databaseSpecialistStructure = (0, factory_1.createAgentStructure)('database-specialist', 'Database Specialist', 'Designs and optimizes database schemas', 'Focus on schema design, query optimization, and data integrity.');
-exports.mobileSpecialistStructure = (0, factory_1.createAgentStructure)('mobile-specialist', 'Mobile Specialist', 'Develops mobile applications', 'Focus on native/cross-platform development, performance, and app store requirements.');
+// ============================================================================
+// Default Content Definitions
+// ============================================================================
+const codeReviewerContent = {
+    mission: `This agent reviews code changes for quality, consistency, and adherence to project standards.
+
+**When to engage:**
+- Pull request reviews
+- Pre-commit code quality checks
+- Architecture decision validation
+- Code pattern compliance verification
+
+**Review focus areas:**
+- Code correctness and logic
+- Performance implications
+- Security considerations
+- Test coverage
+- Documentation completeness`,
+    responsibilities: `- Review pull requests for code quality and correctness
+- Check adherence to project coding standards and conventions
+- Identify potential bugs, edge cases, and error handling gaps
+- Evaluate test coverage for changed code
+- Assess performance implications of changes
+- Flag security vulnerabilities or concerns
+- Suggest improvements for readability and maintainability
+- Verify documentation is updated for public API changes`,
+    bestPractices: `- Start with understanding the context and purpose of changes
+- Focus on the most impactful issues first
+- Provide actionable, specific feedback with examples
+- Distinguish between required changes and suggestions
+- Be respectful and constructive in feedback
+- Check for consistency with existing codebase patterns
+- Consider the reviewer's perspective and time constraints
+- Link to relevant documentation or examples when suggesting changes`,
+    collaborationChecklist: `- [ ] Read the PR description and linked issues to understand context
+- [ ] Review the overall design approach before diving into details
+- [ ] Check that tests cover the main functionality and edge cases
+- [ ] Verify documentation is updated for any API changes
+- [ ] Confirm the PR follows project coding standards
+- [ ] Leave clear, actionable feedback with suggested solutions
+- [ ] Approve or request changes based on review findings`,
+};
+const bugFixerContent = {
+    mission: `This agent analyzes bug reports and implements targeted fixes with minimal side effects.
+
+**When to engage:**
+- Bug reports and issue investigation
+- Production incident response
+- Regression identification
+- Error log analysis
+
+**Fix approach:**
+- Root cause analysis before coding
+- Minimal, focused changes
+- Regression test creation
+- Impact assessment`,
+    responsibilities: `- Analyze bug reports and reproduce issues locally
+- Investigate root causes through debugging and log analysis
+- Implement focused fixes with minimal code changes
+- Write regression tests to prevent recurrence
+- Document the bug cause and fix for future reference
+- Verify fix doesn't introduce new issues
+- Update error handling if gaps are discovered
+- Coordinate with test writer for comprehensive test coverage`,
+    bestPractices: `- Always reproduce the bug before attempting to fix
+- Understand the root cause, not just the symptoms
+- Make the smallest change that fixes the issue
+- Add a test that would have caught this bug
+- Consider if the bug exists elsewhere in similar code
+- Check for related issues that might have the same cause
+- Document the investigation steps for future reference
+- Verify the fix in an environment similar to where the bug occurred`,
+    collaborationChecklist: `- [ ] Reproduce the bug consistently
+- [ ] Identify the root cause through debugging
+- [ ] Implement a minimal, targeted fix
+- [ ] Write a regression test for the bug
+- [ ] Verify the fix doesn't break existing functionality
+- [ ] Document the cause and solution
+- [ ] Update related documentation if needed`,
+};
+const featureDeveloperContent = {
+    mission: `This agent implements new features according to specifications with clean architecture.
+
+**When to engage:**
+- New feature implementation
+- Feature enhancement requests
+- User story development
+- API endpoint additions
+
+**Implementation approach:**
+- Understand requirements thoroughly
+- Design before coding
+- Integrate with existing patterns
+- Write tests alongside code`,
+    responsibilities: `- Implement new features based on specifications and requirements
+- Design solutions that integrate well with existing architecture
+- Write clean, maintainable, and well-documented code
+- Create comprehensive tests for new functionality
+- Handle edge cases and error scenarios gracefully
+- Coordinate with other agents for reviews and testing
+- Update documentation for new features
+- Ensure backward compatibility when modifying existing APIs`,
+    bestPractices: `- Start with understanding the full requirements and acceptance criteria
+- Design the solution before writing code
+- Follow existing code patterns and conventions in the project
+- Write tests as you develop, not as an afterthought
+- Keep commits focused and well-documented
+- Communicate blockers or unclear requirements early
+- Consider performance, security, and accessibility from the start
+- Leave the codebase cleaner than you found it`,
+    collaborationChecklist: `- [ ] Understand requirements and acceptance criteria fully
+- [ ] Design the solution and get feedback on approach
+- [ ] Implement feature following project patterns
+- [ ] Write unit and integration tests
+- [ ] Update relevant documentation
+- [ ] Create PR with clear description and testing notes
+- [ ] Address code review feedback`,
+};
+const refactoringSpecialistContent = {
+    mission: `This agent identifies code smells and improves code structure while preserving functionality.
+
+**When to engage:**
+- Code smell identification
+- Technical debt reduction
+- Architecture improvements
+- Pattern standardization
+
+**Refactoring approach:**
+- Incremental, safe changes
+- Test coverage first
+- Preserve behavior exactly
+- Improve readability and maintainability`,
+    responsibilities: `- Identify code smells and areas needing improvement
+- Plan and execute refactoring in safe, incremental steps
+- Ensure comprehensive test coverage before refactoring
+- Preserve existing functionality exactly
+- Improve code readability and maintainability
+- Reduce duplication and complexity
+- Standardize patterns across the codebase
+- Document architectural decisions and improvements`,
+    bestPractices: `- Never refactor without adequate test coverage
+- Make one type of change at a time (rename, extract, move)
+- Commit frequently with clear descriptions
+- Preserve behavior exactly - refactoring is not feature change
+- Use automated refactoring tools when available
+- Review changes carefully before committing
+- If tests break, the refactoring changed behavior - investigate
+- Keep refactoring PRs focused and reviewable`,
+    collaborationChecklist: `- [ ] Ensure adequate test coverage exists for the code
+- [ ] Identify specific improvements to make
+- [ ] Plan incremental steps for the refactoring
+- [ ] Execute changes one step at a time
+- [ ] Run tests after each step to verify behavior
+- [ ] Update documentation for any structural changes
+- [ ] Request review focusing on behavior preservation`,
+};
+const testWriterContent = {
+    mission: `This agent writes comprehensive tests and maintains test coverage standards.
+
+**When to engage:**
+- New feature testing
+- Bug regression tests
+- Test coverage improvements
+- Test suite maintenance
+
+**Testing approach:**
+- Test pyramid (unit, integration, e2e)
+- Edge case coverage
+- Clear, maintainable tests
+- Fast, reliable execution`,
+    responsibilities: `- Write unit tests for individual functions and components
+- Create integration tests for feature workflows
+- Add end-to-end tests for critical user paths
+- Identify and cover edge cases and error scenarios
+- Maintain test suite performance and reliability
+- Update tests when code changes
+- Improve test coverage for undertested areas
+- Document testing patterns and best practices`,
+    bestPractices: `- Follow the test pyramid: many unit tests, fewer integration, minimal e2e
+- Write tests that are fast, isolated, and deterministic
+- Use descriptive test names that explain what and why
+- Test behavior, not implementation details
+- Cover happy paths, edge cases, and error scenarios
+- Keep tests maintainable and avoid test code duplication
+- Use appropriate mocking strategies
+- Ensure tests can run independently and in any order`,
+    collaborationChecklist: `- [ ] Understand the feature or bug being tested
+- [ ] Identify key test scenarios (happy path, edge cases, errors)
+- [ ] Write unit tests for individual components
+- [ ] Add integration tests for feature workflows
+- [ ] Verify test coverage meets project standards
+- [ ] Ensure tests are fast and reliable
+- [ ] Document any complex test setups or patterns`,
+};
+const documentationWriterContent = {
+    mission: `This agent creates and maintains documentation to keep it in sync with code.
+
+**When to engage:**
+- New feature documentation
+- API reference updates
+- README improvements
+- Code comment reviews
+
+**Documentation approach:**
+- Clear and concise writing
+- Practical code examples
+- Up-to-date with code changes
+- Accessible to target audience`,
+    responsibilities: `- Write and maintain README files and getting started guides
+- Create API documentation with clear examples
+- Document architecture decisions and system design
+- Keep inline code comments accurate and helpful
+- Update documentation when code changes
+- Create tutorials and how-to guides
+- Maintain changelog and release notes
+- Review documentation for clarity and accuracy`,
+    bestPractices: `- Write for your target audience (developers, users, etc.)
+- Include working code examples that can be copied
+- Keep documentation close to the code it describes
+- Update docs in the same PR as code changes
+- Use consistent formatting and terminology
+- Include common use cases and troubleshooting tips
+- Make documentation searchable and well-organized
+- Review docs from a newcomer's perspective`,
+    collaborationChecklist: `- [ ] Identify what needs to be documented
+- [ ] Determine the target audience and their needs
+- [ ] Write clear, concise documentation
+- [ ] Include working code examples
+- [ ] Verify examples work with current code
+- [ ] Review for clarity and completeness
+- [ ] Get feedback from someone unfamiliar with the feature`,
+};
+const performanceOptimizerContent = {
+    mission: `This agent identifies bottlenecks and optimizes performance based on measurements.
+
+**When to engage:**
+- Performance investigations
+- Optimization requests
+- Scalability planning
+- Resource usage concerns
+
+**Optimization approach:**
+- Measure before optimizing
+- Target actual bottlenecks
+- Verify improvements with benchmarks
+- Document trade-offs`,
+    responsibilities: `- Profile and measure performance to identify bottlenecks
+- Optimize algorithms and data structures
+- Implement caching strategies where appropriate
+- Reduce memory usage and prevent leaks
+- Optimize database queries and access patterns
+- Improve network request efficiency
+- Create performance benchmarks and tests
+- Document performance requirements and baselines`,
+    bestPractices: `- Always measure before and after optimization
+- Focus on actual bottlenecks, not assumed ones
+- Profile in production-like conditions
+- Consider the 80/20 rule - optimize what matters most
+- Document performance baselines and targets
+- Be aware of optimization trade-offs (memory vs speed, etc.)
+- Don't sacrifice readability for micro-optimizations
+- Add performance regression tests for critical paths`,
+    collaborationChecklist: `- [ ] Define performance requirements and targets
+- [ ] Profile to identify actual bottlenecks
+- [ ] Propose optimization approach
+- [ ] Implement optimization with minimal side effects
+- [ ] Measure improvement against baseline
+- [ ] Add performance tests to prevent regression
+- [ ] Document the optimization and trade-offs`,
+};
+const securityAuditorContent = {
+    mission: `This agent identifies security vulnerabilities and implements security best practices.
+
+**When to engage:**
+- Security reviews
+- Vulnerability assessments
+- Authentication/authorization changes
+- Sensitive data handling
+
+**Security approach:**
+- OWASP top 10 awareness
+- Defense in depth
+- Principle of least privilege
+- Security testing`,
+    responsibilities: `- Review code for security vulnerabilities
+- Assess authentication and authorization implementations
+- Check for injection vulnerabilities (SQL, XSS, command, etc.)
+- Verify proper handling of sensitive data
+- Review dependency security (known vulnerabilities)
+- Implement security headers and configurations
+- Design secure API endpoints
+- Document security requirements and controls`,
+    bestPractices: `- Never trust user input - always validate and sanitize
+- Apply principle of least privilege
+- Use established security libraries, don't roll your own
+- Keep dependencies updated to patch vulnerabilities
+- Implement defense in depth (multiple security layers)
+- Log security events for monitoring and alerting
+- Encrypt sensitive data at rest and in transit
+- Review authentication and session management carefully`,
+    collaborationChecklist: `- [ ] Review for OWASP top 10 vulnerabilities
+- [ ] Check input validation and sanitization
+- [ ] Verify authentication and authorization
+- [ ] Assess sensitive data handling
+- [ ] Review dependencies for known vulnerabilities
+- [ ] Check security headers and configurations
+- [ ] Document security findings and recommendations`,
+};
+const backendSpecialistContent = {
+    mission: `This agent designs and implements server-side architecture and APIs.
+
+**When to engage:**
+- API design and implementation
+- Service architecture decisions
+- Database integration
+- Backend performance optimization
+
+**Implementation approach:**
+- RESTful or GraphQL API design
+- Service layer patterns
+- Database optimization
+- Authentication and authorization`,
+    responsibilities: `- Design and implement RESTful or GraphQL APIs
+- Create service layer architecture
+- Implement data access patterns and repositories
+- Design and optimize database schemas
+- Set up authentication and authorization
+- Implement background jobs and queues
+- Create API documentation
+- Handle error handling and logging`,
+    bestPractices: `- Follow REST conventions or GraphQL best practices
+- Use proper HTTP status codes and error responses
+- Implement pagination, filtering, and sorting for collections
+- Design idempotent operations where appropriate
+- Use transactions for data consistency
+- Implement proper request validation
+- Cache responses when appropriate
+- Log requests and errors for debugging`,
+    collaborationChecklist: `- [ ] Design API contract and document endpoints
+- [ ] Implement service layer with business logic
+- [ ] Create data access layer and repositories
+- [ ] Add input validation and error handling
+- [ ] Implement authentication if required
+- [ ] Write tests for API endpoints
+- [ ] Update API documentation`,
+};
+const frontendSpecialistContent = {
+    mission: `This agent designs and implements user interfaces with focus on UX and accessibility.
+
+**When to engage:**
+- UI component development
+- State management decisions
+- Accessibility improvements
+- Frontend performance optimization
+
+**Implementation approach:**
+- Component-based architecture
+- Responsive design
+- Accessibility first
+- Performance optimization`,
+    responsibilities: `- Implement UI components and layouts
+- Manage application state effectively
+- Ensure responsive design across devices
+- Implement accessibility standards (WCAG)
+- Optimize frontend performance (bundle size, rendering)
+- Handle form validation and user input
+- Implement client-side routing
+- Create reusable component libraries`,
+    bestPractices: `- Build components that are reusable and composable
+- Follow accessibility guidelines from the start
+- Test on multiple devices and browsers
+- Optimize bundle size and loading performance
+- Use semantic HTML elements
+- Implement proper keyboard navigation
+- Handle loading, error, and empty states
+- Write component tests and visual regression tests`,
+    collaborationChecklist: `- [ ] Review design specifications and requirements
+- [ ] Plan component structure and state management
+- [ ] Implement responsive, accessible components
+- [ ] Handle all UI states (loading, error, empty)
+- [ ] Test across browsers and devices
+- [ ] Optimize performance and bundle size
+- [ ] Write component tests`,
+};
+const architectSpecialistContent = {
+    mission: `This agent designs overall system architecture and establishes technical standards.
+
+**When to engage:**
+- System design decisions
+- Technology selection
+- Architecture reviews
+- Scalability planning
+
+**Design approach:**
+- Scalable and maintainable architecture
+- Clear separation of concerns
+- Technology evaluation
+- Documentation of decisions`,
+    responsibilities: `- Design system architecture and component interactions
+- Evaluate and select technologies and frameworks
+- Establish coding standards and patterns
+- Create architecture decision records (ADRs)
+- Plan for scalability and reliability
+- Review designs for technical soundness
+- Guide team on architectural best practices
+- Balance technical debt with delivery needs`,
+    bestPractices: `- Document architectural decisions and their rationale
+- Design for change - anticipate future requirements
+- Keep architecture as simple as needed
+- Consider operational concerns (monitoring, deployment)
+- Evaluate trade-offs explicitly
+- Use proven patterns and avoid over-engineering
+- Ensure architecture supports testing and debugging
+- Review architecture regularly as requirements evolve`,
+    collaborationChecklist: `- [ ] Understand requirements and constraints
+- [ ] Evaluate architectural options and trade-offs
+- [ ] Design component structure and interactions
+- [ ] Document decisions in ADRs
+- [ ] Review design with team for feedback
+- [ ] Plan implementation approach
+- [ ] Create guidelines for developers`,
+};
+const devopsSpecialistContent = {
+    mission: `This agent designs CI/CD pipelines, infrastructure, and deployment automation.
+
+**When to engage:**
+- CI/CD pipeline setup
+- Infrastructure provisioning
+- Deployment automation
+- Monitoring and alerting
+
+**DevOps approach:**
+- Infrastructure as code
+- Automated testing in pipelines
+- Continuous deployment
+- Observability and monitoring`,
+    responsibilities: `- Design and maintain CI/CD pipelines
+- Provision and manage infrastructure as code
+- Automate deployment processes
+- Set up monitoring, logging, and alerting
+- Manage containerization and orchestration
+- Configure environments (dev, staging, production)
+- Implement security in the deployment pipeline
+- Optimize build and deployment times`,
+    bestPractices: `- Use infrastructure as code for reproducibility
+- Automate everything that can be automated
+- Implement proper secrets management
+- Use immutable deployments when possible
+- Monitor all critical systems and set up alerts
+- Test infrastructure changes before applying
+- Document runbooks for common operations
+- Implement proper backup and recovery procedures`,
+    collaborationChecklist: `- [ ] Define deployment requirements and environments
+- [ ] Design CI/CD pipeline stages
+- [ ] Implement infrastructure as code
+- [ ] Set up automated testing in pipeline
+- [ ] Configure monitoring and alerting
+- [ ] Document deployment procedures
+- [ ] Test rollback and recovery processes`,
+};
+const databaseSpecialistContent = {
+    mission: `This agent designs and optimizes database schemas and queries.
+
+**When to engage:**
+- Schema design decisions
+- Query performance issues
+- Migration planning
+- Data integrity concerns
+
+**Database approach:**
+- Normalized schema design
+- Index optimization
+- Query performance tuning
+- Data migration planning`,
+    responsibilities: `- Design database schemas and relationships
+- Write and optimize complex queries
+- Create and manage database migrations
+- Implement proper indexing strategies
+- Ensure data integrity and consistency
+- Plan for database scaling
+- Optimize query performance
+- Set up database backups and recovery`,
+    bestPractices: `- Design schemas with normalization in mind
+- Use appropriate data types and constraints
+- Index based on actual query patterns
+- Write migrations that are reversible
+- Test migrations on production-like data
+- Monitor query performance and slow queries
+- Use transactions for data consistency
+- Plan for data growth and scaling needs`,
+    collaborationChecklist: `- [ ] Understand data requirements and relationships
+- [ ] Design normalized schema structure
+- [ ] Plan indexing strategy based on queries
+- [ ] Write migration scripts
+- [ ] Test migrations with production-like data
+- [ ] Optimize queries for performance
+- [ ] Document schema and relationships`,
+};
+const mobileSpecialistContent = {
+    mission: `This agent develops mobile applications for iOS and Android platforms.
+
+**When to engage:**
+- Mobile app development
+- Cross-platform decisions
+- Mobile performance issues
+- App store submissions
+
+**Mobile approach:**
+- Platform best practices
+- Performance optimization
+- Offline support
+- Native integrations`,
+    responsibilities: `- Develop mobile applications (native or cross-platform)
+- Implement responsive mobile UI/UX
+- Handle mobile-specific concerns (offline, battery, etc.)
+- Integrate with device features (camera, GPS, etc.)
+- Optimize app performance and startup time
+- Manage app store submissions and updates
+- Implement push notifications
+- Handle mobile security and data storage`,
+    bestPractices: `- Follow platform UI/UX guidelines
+- Optimize for battery and network usage
+- Implement proper offline support
+- Use native components when appropriate
+- Test on real devices, not just simulators
+- Handle different screen sizes and orientations
+- Implement proper error handling for network issues
+- Follow app store guidelines for submissions`,
+    collaborationChecklist: `- [ ] Review mobile design specifications
+- [ ] Plan architecture for cross-platform needs
+- [ ] Implement core functionality
+- [ ] Handle offline and network scenarios
+- [ ] Test on multiple devices and OS versions
+- [ ] Optimize performance and battery usage
+- [ ] Prepare for app store submission`,
+};
+// ============================================================================
+// Agent Structure Exports
+// ============================================================================
+exports.codeReviewerStructure = (0, factory_1.createAgentStructure)('code-reviewer', 'Code Reviewer', 'Reviews code changes for quality, style, and best practices', 'Focus on code quality, maintainability, security issues, and adherence to project conventions.', codeReviewerContent);
+exports.bugFixerStructure = (0, factory_1.createAgentStructure)('bug-fixer', 'Bug Fixer', 'Analyzes bug reports and implements targeted fixes', 'Focus on root cause analysis, minimal side effects, and regression prevention.', bugFixerContent);
+exports.featureDeveloperStructure = (0, factory_1.createAgentStructure)('feature-developer', 'Feature Developer', 'Implements new features according to specifications', 'Focus on clean architecture, integration with existing code, and comprehensive testing.', featureDeveloperContent);
+exports.refactoringSpecialistStructure = (0, factory_1.createAgentStructure)('refactoring-specialist', 'Refactoring Specialist', 'Identifies code smells and improves code structure', 'Focus on incremental changes, test coverage, and preserving functionality.', refactoringSpecialistContent);
+exports.testWriterStructure = (0, factory_1.createAgentStructure)('test-writer', 'Test Writer', 'Writes comprehensive tests and maintains test coverage', 'Focus on unit tests, integration tests, edge cases, and test maintainability.', testWriterContent);
+exports.documentationWriterStructure = (0, factory_1.createAgentStructure)('documentation-writer', 'Documentation Writer', 'Creates and maintains documentation', 'Focus on clarity, practical examples, and keeping docs in sync with code.', documentationWriterContent);
+exports.performanceOptimizerStructure = (0, factory_1.createAgentStructure)('performance-optimizer', 'Performance Optimizer', 'Identifies bottlenecks and optimizes performance', 'Focus on measurement, actual bottlenecks, and caching strategies.', performanceOptimizerContent);
+exports.securityAuditorStructure = (0, factory_1.createAgentStructure)('security-auditor', 'Security Auditor', 'Identifies security vulnerabilities and implements best practices', 'Focus on OWASP top 10, dependency scanning, and principle of least privilege.', securityAuditorContent);
+exports.backendSpecialistStructure = (0, factory_1.createAgentStructure)('backend-specialist', 'Backend Specialist', 'Designs and implements server-side architecture', 'Focus on APIs, microservices, database optimization, and authentication.', backendSpecialistContent);
+exports.frontendSpecialistStructure = (0, factory_1.createAgentStructure)('frontend-specialist', 'Frontend Specialist', 'Designs and implements user interfaces', 'Focus on responsive design, accessibility, state management, and performance.', frontendSpecialistContent);
+exports.architectSpecialistStructure = (0, factory_1.createAgentStructure)('architect-specialist', 'Architect Specialist', 'Designs overall system architecture and patterns', 'Focus on scalability, maintainability, and technical standards.', architectSpecialistContent);
+exports.devopsSpecialistStructure = (0, factory_1.createAgentStructure)('devops-specialist', 'DevOps Specialist', 'Designs CI/CD pipelines and infrastructure', 'Focus on automation, infrastructure as code, and monitoring.', devopsSpecialistContent);
+exports.databaseSpecialistStructure = (0, factory_1.createAgentStructure)('database-specialist', 'Database Specialist', 'Designs and optimizes database schemas', 'Focus on schema design, query optimization, and data integrity.', databaseSpecialistContent);
+exports.mobileSpecialistStructure = (0, factory_1.createAgentStructure)('mobile-specialist', 'Mobile Specialist', 'Develops mobile applications', 'Focus on native/cross-platform development, performance, and app store requirements.', mobileSpecialistContent);
 //# sourceMappingURL=definitions.js.map

package/dist/generators/shared/structures/agents/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../../../../src/generators/shared/structures/agents/definitions.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,uCAAiD;AAEpC,QAAA,qBAAqB,GAAG,IAAA,8BAAoB,EACvD,eAAe,EACf,eAAe,EACf,6DAA6D,EAC7D,gGAAgG,CACjG,CAAC;AAEW,QAAA,iBAAiB,GAAG,IAAA,8BAAoB,EACnD,WAAW,EACX,WAAW,EACX,oDAAoD,EACpD,gFAAgF,CACjF,CAAC;AAEW,QAAA,yBAAyB,GAAG,IAAA,8BAAoB,EAC3D,mBAAmB,EACnB,mBAAmB,EACnB,qDAAqD,EACrD,yFAAyF,CAC1F,CAAC;AAEW,QAAA,8BAA8B,GAAG,IAAA,8BAAoB,EAChE,wBAAwB,EACxB,wBAAwB,EACxB,oDAAoD,EACpD,4EAA4E,CAC7E,CAAC;AAEW,QAAA,mBAAmB,GAAG,IAAA,8BAAoB,EACrD,aAAa,EACb,aAAa,EACb,wDAAwD,EACxD,+EAA+E,CAChF,CAAC;AAEW,QAAA,4BAA4B,GAAG,IAAA,8BAAoB,EAC9D,sBAAsB,EACtB,sBAAsB,EACtB,qCAAqC,EACrC,2EAA2E,CAC5E,CAAC;AAEW,QAAA,6BAA6B,GAAG,IAAA,8BAAoB,EAC/D,uBAAuB,EACvB,uBAAuB,EACvB,kDAAkD,EAClD,mEAAmE,CACpE,CAAC;AAEW,QAAA,wBAAwB,GAAG,IAAA,8BAAoB,EAC1D,kBAAkB,EAClB,kBAAkB,EAClB,mEAAmE,EACnE,+EAA+E,CAChF,CAAC;AAEW,QAAA,0BAA0B,GAAG,IAAA,8BAAoB,EAC5D,oBAAoB,EACpB,oBAAoB,EACpB,iDAAiD,EACjD,0EAA0E,CAC3E,CAAC;AAEW,QAAA,2BAA2B,GAAG,IAAA,8BAAoB,EAC7D,qBAAqB,EACrB,qBAAqB,EACrB,wCAAwC,EACxC,+EAA+E,CAChF,CAAC;AAEW,QAAA,4BAA4B,GAAG,IAAA,8BAAoB,EAC9D,sBAAsB,EACtB,sBAAsB,EACtB,kDAAkD,EAClD,iEAAiE,CAClE,CAAC;AAEW,QAAA,yBAAyB,GAAG,IAAA,8BAAoB,EAC3D,mBAAmB,EACnB,mBAAmB,EACnB,4CAA4C,EAC5C,8DAA8D,CAC/D,CAAC;AAEW,QAAA,2BAA2B,GAAG,IAAA,8BAAoB,EAC7D,qBAAqB,EACrB,qBAAqB,EACrB,wCAAwC,EACxC,iEAAiE,CAClE,CAAC;AAEW,QAAA,yBAAyB,GAAG,IAAA,8BAAoB,EAC3D,mBAAmB,EACnB,mBAAmB,EACnB,8BAA8B,EAC9B,sFAAsF,CACvF,CAAC"}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../../../../src/generators/shared/structures/agents/definitions.ts"],"names":[],"mappings":"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"}

package/dist/generators/shared/structures/agents/factory.d.ts

@@ -2,8 +2,24 @@
  * Factory function for creating agent structures
  */
 import { ScaffoldStructure } from '../types';
+/**
+ * Default content overrides for specific sections
+ */
+export interface AgentDefaultContent {
+    mission?: string;
+    responsibilities?: string;
+    bestPractices?: string;
+    keyProjectResources?: string;
+    repositoryStartingPoints?: string;
+    keyFiles?: string;
+    architectureContext?: string;
+    keySymbols?: string;
+    documentationTouchpoints?: string;
+    collaborationChecklist?: string;
+    handoffNotes?: string;
+}
 /**
  * Create an agent structure with standard sections
  */
-export declare function createAgentStructure(agentType: string, title: string, description: string, additionalContext?: string): ScaffoldStructure;
+export declare function createAgentStructure(agentType: string, title: string, description: string, additionalContext?: string, defaultContent?: AgentDefaultContent): ScaffoldStructure;
 //# sourceMappingURL=factory.d.ts.map

package/dist/generators/shared/structures/agents/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../../src/generators/shared/structures/agents/factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,GACzB,iBAAiB,CAqGnB"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../../src/generators/shared/structures/agents/factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAmB,MAAM,UAAU,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAmBD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,cAAc,CAAC,EAAE,mBAAmB,GACnC,iBAAiB,CAiHnB"}