agentic-qe 1.1.0 → 1.2.0

package/dist/cli/commands/init.js

@@ -44,7 +44,7 @@ const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 class InitCommand {
     static async execute(options) {
-        console.log(chalk_1.default.blue.bold('\n🚀 Initializing Agentic QE Project (v1.1.0)\n'));
+        console.log(chalk_1.default.blue.bold('\n🚀 Initializing Agentic QE Project (v1.2.0)\n'));
         try {
             // Parse options
             const maxAgents = parseInt(options.maxAgents);
@@ -84,8 +84,9 @@ class InitCommand {
                     timeout: 1800000
                 }
             };
-            // Interactive project setup if needed
-            if (!options.config) {
+            // Interactive project setup if needed (skip if --non-interactive or --yes)
+            const isNonInteractive = options.nonInteractive || options.yes;
+            if (!options.config && !isNonInteractive) {
                 const projectAnswers = await inquirer_1.default.prompt([
                     {
                         type: 'input',
@@ -144,10 +145,28 @@ class InitCommand {
                 options.enableImprovement = true;
             }
             else {
+                // Non-interactive mode: use defaults or environment variables
+                fleetConfig.project = {
+                    name: process.env.AQE_PROJECT_NAME || path.basename(process.cwd()),
+                    path: process.cwd(),
+                    language: (process.env.AQE_LANGUAGE || 'typescript').toLowerCase()
+                };
+                // Use environment variables or defaults
+                if (fleetConfig.routing) {
+                    fleetConfig.routing.enabled = process.env.AQE_ROUTING_ENABLED === 'true' || false;
+                }
+                if (fleetConfig.streaming) {
+                    fleetConfig.streaming.enabled = process.env.AQE_STREAMING_ENABLED !== 'false';
+                }
                 // Use defaults if non-interactive
-                options.enableLearning = true;
-                options.enablePatterns = true;
-                options.enableImprovement = true;
+                options.enableLearning = process.env.AQE_LEARNING_ENABLED !== 'false';
+                options.enablePatterns = process.env.AQE_PATTERNS_ENABLED !== 'false';
+                options.enableImprovement = process.env.AQE_IMPROVEMENT_ENABLED !== 'false';
+                console.log(chalk_1.default.gray('  ℹ️  Running in non-interactive mode with defaults'));
+                console.log(chalk_1.default.gray(`  • Project: ${fleetConfig.project.name}`));
+                console.log(chalk_1.default.gray(`  • Language: ${fleetConfig.project.language}`));
+                console.log(chalk_1.default.gray(`  • Routing: ${fleetConfig.routing?.enabled ? 'enabled' : 'disabled'}`));
+                console.log(chalk_1.default.gray(`  • Streaming: ${fleetConfig.streaming?.enabled ? 'enabled' : 'disabled'}`));
             }
             const spinner = (0, ora_1.default)('Setting up fleet infrastructure...').start();
             // Create directory structure
@@ -235,6 +254,8 @@ class InitCommand {
             '.agentic-qe/state/coordination', // Coordination state
             '.claude', // For Claude Code integration
             '.claude/agents', // Where agent definitions live
+            '.claude/skills', // Where QE skill definitions live (17 QE skills only)
+            '.claude/commands', // Where AQE slash commands live (8 commands)
             'tests/unit',
             'tests/integration',
             'tests/e2e',
@@ -246,6 +267,10 @@ class InitCommand {
         }
         // Copy agent templates from agentic-qe package
         await this.copyAgentTemplates();
+        // Copy skill templates (only QE Fleet skills, not Claude Flow)
+        await this.copySkillTemplates();
+        // Copy command templates (8 AQE slash commands)
+        await this.copyCommandTemplates();
     }
     static async copyAgentTemplates() {
         console.log(chalk_1.default.cyan('  🔍 Searching for agent templates...'));
@@ -343,6 +368,7 @@ class InitCommand {
                 }
                 const agentFile = path.join(targetPath, `${agentName}.md`);
                 const agentType = agentName.replace('qe-', '');
+                const skills = this.getAgentSkills(agentName);
                 const content = `---
 name: ${agentName}
 type: ${agentType}
@@ -351,13 +377,22 @@ priority: medium
 description: "Agentic QE Fleet ${agentType} agent"
 capabilities:
   - ${agentType}
+skills:
+${skills.map(s => `  - ${s}`).join('\n')}
 coordination:
   protocol: aqe-hooks
+learning:
+  enabled: true
+  observability:
+    - agent.getLearningStatus()
+    - agent.getLearnedPatterns()
+    - agent.recommendStrategy(state)
 metadata:
-  version: "1.0.5"
+  version: "1.1.0"
   framework: "agentic-qe"
   routing: "supported"
   streaming: "supported"
+  phase2: "q-learning-enabled"
 ---
 
 # ${agentName.toUpperCase()} Agent
@@ -369,6 +404,68 @@ This agent is part of the Agentic QE Fleet and specializes in ${agentType}.
 - AI-powered ${agentType}
 - Integration with Agentic QE Fleet
 - Native TypeScript coordination
+- **Q-Learning**: Learns from task execution automatically
+- **Pattern Bank**: Uses proven test patterns
+- **Improvement Loop**: Continuously optimizes strategies
+
+## 🧠 Q-Learning Integration (Phase 2)
+
+This agent automatically learns from EVERY task execution through Q-learning integration in \`BaseAgent.onPostTask()\`.
+
+### Observability Methods
+
+\`\`\`typescript
+// 1. Check learning status
+const status = agent.getLearningStatus();
+console.log(status);
+// {
+//   enabled: true,
+//   totalExperiences: 1247,
+//   explorationRate: 0.08,
+//   patterns: 34
+// }
+
+// 2. View learned patterns
+const patterns = agent.getLearnedPatterns();
+console.log(patterns[0]);
+// {
+//   state: { taskComplexity: 'high', ... },
+//   action: 'thorough-deep-analysis',
+//   qValue: 0.8734,
+//   successRate: 0.88
+// }
+
+// 3. Get strategy recommendations
+const recommendation = await agent.recommendStrategy({
+  taskComplexity: 'medium',
+  availableCapabilities: agent.capabilities
+});
+console.log(recommendation);
+// {
+//   action: 'balanced-coverage',
+//   confidence: 0.92,
+//   expectedQValue: 0.7845
+// }
+\`\`\`
+
+### CLI Commands
+
+\`\`\`bash
+# Check learning status
+aqe learn status --agent ${agentName}
+
+# View learned patterns
+aqe learn history --agent ${agentName} --limit 50
+
+# Export learning data
+aqe learn export --agent ${agentName} --output learning.json
+\`\`\`
+
+## Skills
+
+This agent can use the following Claude Code Skills:
+
+${this.getSkillDocumentation(agentName)}
 
 ## Coordination Protocol
 
@@ -536,6 +633,7 @@ For full capabilities, install the complete agentic-qe package.
         for (const agentName of missingAgents) {
             const agentFile = path.join(targetPath, `${agentName}.md`);
             const agentType = agentName.replace('qe-', '');
+            const skills = this.getAgentSkills(agentName);
             const content = `---
 name: ${agentName}
 type: ${agentType}
@@ -544,13 +642,22 @@ priority: medium
 description: "Agentic QE Fleet ${agentType} agent"
 capabilities:
   - ${agentType}
+skills:
+${skills.map(s => `  - ${s}`).join('\n')}
 coordination:
   protocol: aqe-hooks
+learning:
+  enabled: true
+  observability:
+    - agent.getLearningStatus()
+    - agent.getLearnedPatterns()
+    - agent.recommendStrategy(state)
 metadata:
   version: "1.1.0"
   framework: "agentic-qe"
   routing: "supported"
   streaming: "supported"
+  phase2: "q-learning-enabled"
 ---
 
 # ${agentName.toUpperCase()} Agent
@@ -562,6 +669,15 @@ This agent is part of the Agentic QE Fleet and specializes in ${agentType}.
 - AI-powered ${agentType}
 - Integration with Agentic QE Fleet
 - Native TypeScript coordination
+- **Q-Learning**: Learns from task execution automatically
+- **Pattern Bank**: Uses proven test patterns
+- **Improvement Loop**: Continuously optimizes strategies
+
+## Skills
+
+This agent can use the following Claude Code Skills:
+
+${this.getSkillDocumentation(agentName)}
 
 ## Coordination Protocol
 
@@ -581,6 +697,213 @@ For full capabilities, install the complete agentic-qe package.
         const files = await fs.readdir(dirPath);
         return files.filter(f => f.endsWith('.md')).length;
     }
+    /**
+     * Copy only the 17 QE Fleet skills (filters out Claude Flow skills)
+     */
+    static async copySkillTemplates() {
+        console.log(chalk_1.default.cyan('  🎯 Initializing QE Fleet skills...'));
+        // Define the 17 QE Fleet skills (from SKILLS-MAPPING.md)
+        const QE_FLEET_SKILLS = [
+            // Core Quality Practices (5)
+            'holistic-testing-pact',
+            'context-driven-testing',
+            'agentic-quality-engineering',
+            'exploratory-testing-advanced',
+            'risk-based-testing',
+            // Development Methodologies (3)
+            'tdd-london-chicago',
+            'xp-practices',
+            'refactoring-patterns',
+            // Testing Specializations (4)
+            'api-testing-patterns',
+            'performance-testing',
+            'security-testing',
+            'test-automation-strategy',
+            // Communication & Process (3)
+            'technical-writing',
+            'bug-reporting-excellence',
+            'code-review-quality',
+            // Professional Skills (2)
+            'consultancy-practices',
+            'quality-metrics'
+        ];
+        // Find the agentic-qe package location
+        const possiblePaths = [
+            path.join(__dirname, '../../../.claude/skills'), // From dist/cli/commands
+            path.join(process.cwd(), 'node_modules/agentic-qe/.claude/skills'),
+            path.join(process.cwd(), '../agentic-qe/.claude/skills') // Monorepo case
+        ];
+        console.log(chalk_1.default.gray('  • Checking skill source paths:'));
+        let sourcePath = null;
+        for (const p of possiblePaths) {
+            const exists = await fs.pathExists(p);
+            console.log(chalk_1.default.gray(`    ${exists ? '✓' : '✗'} ${p}`));
+            if (exists && !sourcePath) {
+                sourcePath = p;
+            }
+        }
+        if (!sourcePath) {
+            console.warn(chalk_1.default.yellow('  ⚠️  No skill templates found in package paths'));
+            console.warn(chalk_1.default.yellow('  ℹ️  Skills can be added manually to .claude/skills/'));
+            return;
+        }
+        console.log(chalk_1.default.green(`  ✓ Found skill templates at: ${sourcePath}`));
+        // List all available skills
+        const availableDirs = await fs.readdir(sourcePath);
+        const availableSkills = availableDirs.filter(name => {
+            const skillPath = path.join(sourcePath, name);
+            try {
+                return fs.statSync(skillPath).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        console.log(chalk_1.default.cyan(`  📦 Found ${availableSkills.length} total skills in source`));
+        // Filter to only QE Fleet skills
+        const qeSkillsToConfig = availableSkills.filter(skill => QE_FLEET_SKILLS.includes(skill));
+        console.log(chalk_1.default.cyan(`  🎯 Filtering to ${qeSkillsToConfig.length} QE Fleet skills (excluding Claude Flow skills)`));
+        const targetPath = path.join(process.cwd(), '.claude/skills');
+        let copiedCount = 0;
+        // Copy each QE skill directory
+        for (const skillName of qeSkillsToConfig) {
+            const sourceSkillPath = path.join(sourcePath, skillName);
+            const targetSkillPath = path.join(targetPath, skillName);
+            // Skip if already exists
+            if (await fs.pathExists(targetSkillPath)) {
+                console.log(chalk_1.default.gray(`    • Skipped ${skillName} (already exists)`));
+                continue;
+            }
+            // Copy the entire skill directory
+            await fs.copy(sourceSkillPath, targetSkillPath);
+            copiedCount++;
+            console.log(chalk_1.default.gray(`    ✓ Copied ${skillName}`));
+        }
+        // Final count
+        const finalSkillCount = await this.countSkillDirs(targetPath);
+        if (copiedCount > 0) {
+            console.log(chalk_1.default.green(`  ✓ Copied ${copiedCount} new QE skills`));
+        }
+        else {
+            console.log(chalk_1.default.green('  ✓ All QE skills already present'));
+        }
+        console.log(chalk_1.default.cyan(`  📋 Total QE skills initialized: ${finalSkillCount}`));
+        // Verify we have exactly 17 QE skills
+        if (finalSkillCount === 17) {
+            console.log(chalk_1.default.green('  ✅ All 17 QE Fleet skills successfully initialized'));
+        }
+        else if (finalSkillCount < 17) {
+            console.warn(chalk_1.default.yellow(`  ⚠️  Expected 17 QE skills, found ${finalSkillCount}`));
+            const missingSkills = QE_FLEET_SKILLS.filter(skill => {
+                return !fs.existsSync(path.join(targetPath, skill));
+            });
+            console.warn(chalk_1.default.yellow(`  ℹ️  Missing skills: ${missingSkills.join(', ')}`));
+        }
+    }
+    /**
+     * Count skill directories in .claude/skills
+     */
+    static async countSkillDirs(dirPath) {
+        if (!await fs.pathExists(dirPath))
+            return 0;
+        const items = await fs.readdir(dirPath);
+        let count = 0;
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item);
+            try {
+                if (fs.statSync(itemPath).isDirectory()) {
+                    count++;
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return count;
+    }
+    /**
+     * Copy AQE slash command templates (8 commands)
+     */
+    static async copyCommandTemplates() {
+        console.log(chalk_1.default.cyan('  ⚡ Initializing AQE slash commands...'));
+        // Define the 8 AQE slash commands
+        const AQE_COMMANDS = [
+            'aqe-analyze.md',
+            'aqe-benchmark.md',
+            'aqe-chaos.md',
+            'aqe-execute.md',
+            'aqe-fleet-status.md',
+            'aqe-generate.md',
+            'aqe-optimize.md',
+            'aqe-report.md'
+        ];
+        // Find the agentic-qe package location
+        const possiblePaths = [
+            path.join(__dirname, '../../../.claude/commands'), // From dist/cli/commands
+            path.join(process.cwd(), 'node_modules/agentic-qe/.claude/commands'),
+            path.join(process.cwd(), '../agentic-qe/.claude/commands') // Monorepo case
+        ];
+        console.log(chalk_1.default.gray('  • Checking command source paths:'));
+        let sourcePath = null;
+        for (const p of possiblePaths) {
+            const exists = await fs.pathExists(p);
+            console.log(chalk_1.default.gray(`    ${exists ? '✓' : '✗'} ${p}`));
+            if (exists && !sourcePath) {
+                sourcePath = p;
+            }
+        }
+        if (!sourcePath) {
+            console.warn(chalk_1.default.yellow('  ⚠️  No command templates found in package paths'));
+            console.warn(chalk_1.default.yellow('  ℹ️  Commands can be added manually to .claude/commands/'));
+            return;
+        }
+        console.log(chalk_1.default.green(`  ✓ Found command templates at: ${sourcePath}`));
+        const targetPath = path.join(process.cwd(), '.claude/commands');
+        let copiedCount = 0;
+        // Copy each AQE command file
+        for (const commandFile of AQE_COMMANDS) {
+            const sourceFile = path.join(sourcePath, commandFile);
+            const targetFile = path.join(targetPath, commandFile);
+            // Skip if already exists or if source doesn't exist
+            if (await fs.pathExists(targetFile)) {
+                console.log(chalk_1.default.gray(`    • Skipped ${commandFile} (already exists)`));
+                continue;
+            }
+            if (!await fs.pathExists(sourceFile)) {
+                console.log(chalk_1.default.gray(`    • Skipped ${commandFile} (source not found)`));
+                continue;
+            }
+            // Copy the command file
+            await fs.copy(sourceFile, targetFile);
+            copiedCount++;
+            console.log(chalk_1.default.gray(`    ✓ Copied ${commandFile}`));
+        }
+        // Count final commands
+        const finalCommandCount = await this.countCommandFiles(targetPath);
+        if (copiedCount > 0) {
+            console.log(chalk_1.default.green(`  ✓ Copied ${copiedCount} new AQE commands`));
+        }
+        else {
+            console.log(chalk_1.default.green('  ✓ All AQE commands already present'));
+        }
+        console.log(chalk_1.default.cyan(`  📋 Total AQE commands initialized: ${finalCommandCount}`));
+        // Verify we have all 8 AQE commands
+        if (finalCommandCount >= 8) {
+            console.log(chalk_1.default.green('  ✅ All 8 AQE slash commands successfully initialized'));
+        }
+        else if (finalCommandCount < 8) {
+            console.warn(chalk_1.default.yellow(`  ⚠️  Expected 8 AQE commands, found ${finalCommandCount}`));
+        }
+    }
+    /**
+     * Count command files in .claude/commands
+     */
+    static async countCommandFiles(dirPath) {
+        if (!await fs.pathExists(dirPath))
+            return 0;
+        const items = await fs.readdir(dirPath);
+        return items.filter(f => f.startsWith('aqe-') && f.endsWith('.md')).length;
+    }
     static async writeFleetConfig(config) {
         console.log(chalk_1.default.cyan('  📝 Writing fleet configuration...'));
         // Sanitize config to remove undefined values that cause jsonfile errors
@@ -729,6 +1052,7 @@ For full capabilities, install the complete agentic-qe package.
                     alerts: env === 'production'
                 }
             };
+            return configs;
         }, {});
     }
     static async setupClaudeFlowIntegration(config) {
@@ -1084,9 +1408,106 @@ for await (const event of handler.execute(params)) {
 - ⚠️  Test generation (coming in v1.1.0)
 - ⚠️  Security scanning (coming in v1.1.0)
 
+## 🎯 Claude Code Skills Integration
+
+This fleet includes **17 specialized QE skills** that agents can use:
+
+### Quality Engineering Skills (10 skills)
+- **agentic-quality-engineering**: Using AI agents as force multipliers in quality work - autonomous testing systems, PACT principles, scaling quality engineering with intelligent agents
+- **api-testing-patterns**: Comprehensive API testing patterns including contract testing, REST/GraphQL testing, and integration testing
+- **bug-reporting-excellence**: Write high-quality bug reports that get fixed quickly - includes templates, examples, and best practices
+- **context-driven-testing**: Apply context-driven testing principles where practices are chosen based on project context, not universal "best practices"
+- **exploratory-testing-advanced**: Advanced exploratory testing techniques with Session-Based Test Management (SBTM), RST heuristics, and test tours
+- **holistic-testing-pact**: Apply the Holistic Testing Model evolved with PACT (Proactive, Autonomous, Collaborative, Targeted) principles
+- **tdd-london-chicago**: Apply both London and Chicago school TDD approaches - understanding different TDD philosophies and choosing the right testing style
+- **pair-programming**: AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, quality monitoring
+- **verification-quality**: Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold
+- **xp-practices**: Apply XP practices including pair programming, ensemble programming, continuous integration, and sustainable pace
+
+### AgentDB Skills (5 skills)
+- **agentdb-advanced**: Master advanced AgentDB features including QUIC synchronization, multi-database management, custom distance metrics, hybrid search
+- **agentdb-learning**: Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms (Decision Transformer, Q-Learning, SARSA, Actor-Critic)
+- **agentdb-memory-patterns**: Implement persistent memory patterns for AI agents using AgentDB (session memory, long-term storage, pattern learning)
+- **agentdb-optimization**: Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching
+- **agentdb-vector-search**: Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying
+
+### Using Skills
+
+#### Via CLI
+\\\`\\\`\\\`bash
+# List all available skills
+aqe skills list
+
+# Search for specific skills
+aqe skills search "testing"
+
+# Show skill details
+aqe skills show agentic-quality-engineering
+
+# Show skill statistics
+aqe skills stats
+\\\`\\\`\\\`
+
+#### Via Skill Tool in Claude Code
+\\\`\\\`\\\`javascript
+// Execute a skill
+Skill("agentic-quality-engineering")
+Skill("tdd-london-chicago")
+Skill("api-testing-patterns")
+\\\`\\\`\\\`
+
+#### Integration with Agents
+All QE agents automatically have access to relevant skills based on their specialization:
+- **Test generators** use: agentic-quality-engineering, api-testing-patterns, tdd-london-chicago
+- **Coverage analyzers** use: agentic-quality-engineering, quality-metrics, risk-based-testing
+- **Flaky test hunters** use: agentic-quality-engineering, exploratory-testing-advanced
+- **Performance testers** use: agentic-quality-engineering, performance-testing, quality-metrics
+- **Security scanners** use: agentic-quality-engineering, security-testing, risk-based-testing
+
+## 🧠 Q-Learning Integration (Phase 2)
+
+All agents automatically learn from task execution through Q-learning:
+
+### Observability
+\\\`\\\`\\\`bash
+# Check learning status
+aqe learn status --agent test-gen
+
+# View learned patterns
+aqe learn history --agent test-gen --limit 50
+
+# Export learning data
+aqe learn export --agent test-gen --output learning.json
+\\\`\\\`\\\`
+
+### Pattern Management
+\\\`\\\`\\\`bash
+# List test patterns
+aqe patterns list --framework jest
+
+# Search patterns
+aqe patterns search "api validation"
+
+# Extract patterns from tests
+aqe patterns extract ./tests --framework jest
+\\\`\\\`\\\`
+
+### Improvement Loop
+\\\`\\\`\\\`bash
+# Start continuous improvement
+aqe improve start
+
+# Check improvement status
+aqe improve status
+
+# Run single improvement cycle
+aqe improve cycle
+\\\`\\\`\\\`
+
 ## 📚 Documentation
 
 - **Agent Definitions**: \\\`.claude/agents/\\\` - ${agentCount} specialized QE agents
+- **Skills**: \\\`.claude/skills/\\\` - 17 specialized QE skills for agents
 - **Fleet Config**: \\\`.agentic-qe/config/fleet.json\\\`
 - **Routing Config**: \\\`.agentic-qe/config/routing.json\\\` (Multi-Model Router settings)
 - **AQE Hooks Config**: \\\`.agentic-qe/config/aqe-hooks.json\\\` (zero dependencies, 100-500x faster)
@@ -1566,6 +1987,53 @@ VALUES ('1.1.0', 'Initial QE ReasoningBank schema');
         console.log(chalk_1.default.gray('  • Improvement loop optimizes continuously (1 hour cycles)'));
         console.log('');
     }
+    /**
+     * Get relevant skills for an agent
+     */
+    static getAgentSkills(agentName) {
+        const skillMap = {
+            'qe-test-generator': ['agentic-quality-engineering', 'api-testing-patterns', 'tdd-london-chicago', 'test-automation-strategy'],
+            'qe-coverage-analyzer': ['agentic-quality-engineering', 'quality-metrics', 'risk-based-testing'],
+            'qe-flaky-test-hunter': ['agentic-quality-engineering', 'exploratory-testing-advanced', 'risk-based-testing'],
+            'qe-performance-tester': ['agentic-quality-engineering', 'performance-testing', 'quality-metrics'],
+            'qe-security-scanner': ['agentic-quality-engineering', 'security-testing', 'risk-based-testing'],
+            'qe-quality-gate': ['agentic-quality-engineering', 'quality-metrics', 'risk-based-testing'],
+            'qe-api-contract-validator': ['agentic-quality-engineering', 'api-testing-patterns'],
+            'qe-test-executor': ['agentic-quality-engineering', 'test-automation-strategy'],
+            'qe-requirements-validator': ['agentic-quality-engineering', 'context-driven-testing'],
+            'qe-quality-analyzer': ['agentic-quality-engineering', 'quality-metrics'],
+            'qe-visual-tester': ['agentic-quality-engineering', 'exploratory-testing-advanced'],
+            'qe-chaos-engineer': ['agentic-quality-engineering', 'risk-based-testing'],
+            'qe-production-intelligence': ['agentic-quality-engineering', 'context-driven-testing'],
+            'qe-fleet-commander': ['agentic-quality-engineering'],
+            'qe-deployment-readiness': ['agentic-quality-engineering', 'risk-based-testing', 'quality-metrics'],
+            'qe-regression-risk-analyzer': ['agentic-quality-engineering', 'risk-based-testing'],
+            'qe-test-data-architect': ['agentic-quality-engineering', 'test-automation-strategy']
+        };
+        return skillMap[agentName] || ['agentic-quality-engineering'];
+    }
+    /**
+     * Get skill documentation for agent
+     */
+    static getSkillDocumentation(agentName) {
+        const skills = this.getAgentSkills(agentName);
+        const skillDescriptions = {
+            'agentic-quality-engineering': 'AI agents as force multipliers in quality work (PACT principles)',
+            'api-testing-patterns': 'REST, GraphQL, contract testing patterns',
+            'tdd-london-chicago': 'Both TDD schools, when to use each approach',
+            'test-automation-strategy': 'When/how to automate effectively',
+            'quality-metrics': 'Meaningful metrics vs vanity metrics',
+            'risk-based-testing': 'Focus testing where failure hurts most',
+            'exploratory-testing-advanced': 'RST heuristics, SBTM, test tours',
+            'performance-testing': 'Load, stress, soak testing strategies',
+            'security-testing': 'OWASP Top 10, vulnerability patterns',
+            'context-driven-testing': 'RST techniques and contextual best practices'
+        };
+        return skills.map(skill => {
+            const description = skillDescriptions[skill] || 'Quality engineering expertise';
+            return `- **${skill}**: ${description}`;
+        }).join('\n');
+    }
 }
 exports.InitCommand = InitCommand;
 //# sourceMappingURL=init.js.map