agentic-qe 1.8.4 → 1.9.1

package/dist/cli/commands/constitution.js

@@ -0,0 +1,679 @@
+"use strict";
+/**
+ * Constitution CLI Commands
+ *
+ * Provides commands for managing and evaluating quality constitutions:
+ * - validate: Validate constitution files against schema
+ * - list: List all loaded constitutions
+ * - show: Display details of a specific constitution
+ * - evaluate: Evaluate files against constitution with agent voting
+ *
+ * @module cli/commands/constitution
+ * @version 1.0.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConstitutionValidateCommand = createConstitutionValidateCommand;
+exports.createConstitutionListCommand = createConstitutionListCommand;
+exports.createConstitutionShowCommand = createConstitutionShowCommand;
+exports.createConstitutionEvaluateCommand = createConstitutionEvaluateCommand;
+exports.createConstitutionCommand = createConstitutionCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const loader_1 = require("../../constitution/loader");
+const base_1 = require("../../constitution/evaluators/base");
+const orchestrator_1 = require("../../voting/orchestrator");
+/**
+ * Validate constitution command
+ */
+function createConstitutionValidateCommand() {
+    return new commander_1.Command('validate')
+        .description('Validate constitution file(s) against schema')
+        .argument('[path]', 'Path to constitution file or directory', (0, loader_1.getBaseConstitutionsPath)())
+        .option('--strict', 'Strict validation mode')
+        .option('--json', 'Output as JSON')
+        .action(async (pathArg, options) => {
+        const spinner = (0, ora_1.default)('Validating constitutions...').start();
+        try {
+            const loader = (0, loader_1.getDefaultLoader)();
+            const absolutePath = path.resolve(pathArg);
+            const stats = await fs.stat(absolutePath);
+            let results = [];
+            if (stats.isDirectory()) {
+                // Validate all constitutions in directory
+                const files = await fs.readdir(absolutePath);
+                const constitutionFiles = files.filter(f => f.endsWith('.constitution.json'));
+                for (const file of constitutionFiles) {
+                    const filePath = path.join(absolutePath, file);
+                    try {
+                        const constitution = loader.loadConstitution(filePath, { validate: false });
+                        const result = loader.validateConstitution(constitution);
+                        results.push({ path: filePath, result, constitution });
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        results.push({
+                            path: filePath,
+                            result: {
+                                valid: false,
+                                errors: [{ path: '/', message: errorMessage, code: 'LOAD_ERROR' }],
+                                warnings: []
+                            }
+                        });
+                    }
+                }
+            }
+            else {
+                // Validate single file
+                const constitution = loader.loadConstitution(absolutePath, { validate: false });
+                const result = loader.validateConstitution(constitution);
+                results.push({ path: absolutePath, result, constitution });
+            }
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(results, null, 2));
+            }
+            else {
+                displayValidationResults(results);
+            }
+            // Exit with error if any validation failed
+            const hasErrors = results.some(r => !r.result.valid);
+            process.exit(hasErrors ? 1 : 0);
+        }
+        catch (error) {
+            spinner.fail('Validation failed');
+            console.error(chalk_1.default.red('Error:'), error);
+            process.exit(1);
+        }
+    });
+}
+/**
+ * List constitutions command
+ */
+function createConstitutionListCommand() {
+    return new commander_1.Command('list')
+        .description('List all available constitutions')
+        .option('-d, --directory <path>', 'Constitution directory', (0, loader_1.getBaseConstitutionsPath)())
+        .option('--detailed', 'Show detailed information')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const loader = (0, loader_1.getDefaultLoader)();
+            const constitutions = loader.loadConstitutions(options.directory);
+            if (options.json) {
+                const constitutionArray = Array.from(constitutions.values());
+                console.log(JSON.stringify(constitutionArray, null, 2));
+            }
+            else {
+                displayConstitutionList(constitutions, options.detailed);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error);
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Show constitution details command
+ */
+function createConstitutionShowCommand() {
+    return new commander_1.Command('show')
+        .description('Show detailed information about a constitution')
+        .argument('<id>', 'Constitution ID or file path')
+        .option('-d, --directory <path>', 'Constitution directory', (0, loader_1.getBaseConstitutionsPath)())
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        try {
+            const loader = (0, loader_1.getDefaultLoader)();
+            let constitution;
+            // Try to load as file path first
+            if (await fs.stat(id).catch(() => null)) {
+                constitution = loader.loadConstitution(id);
+            }
+            else {
+                // Load from directory by ID
+                const constitutions = loader.loadConstitutions(options.directory);
+                const found = constitutions.get(id);
+                if (!found) {
+                    console.error(chalk_1.default.red(`Constitution not found: ${id}`));
+                    console.log(chalk_1.default.gray(`Available: ${Array.from(constitutions.keys()).join(', ')}`));
+                    process.exit(1);
+                }
+                constitution = found;
+            }
+            if (options.json) {
+                console.log(JSON.stringify(constitution, null, 2));
+            }
+            else {
+                displayConstitutionDetails(constitution);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error:'), error);
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Evaluate files against constitution command
+ */
+function createConstitutionEvaluateCommand() {
+    return new commander_1.Command('evaluate')
+        .description('Evaluate file(s) against constitution with agent voting')
+        .argument('<files...>', 'File(s) to evaluate')
+        .option('--output <format>', 'Output format (human|json|agent)', 'human')
+        .option('--min-agents <n>', 'Minimum voting agents', parseInt, 3)
+        .option('--constitution <id>', 'Constitution ID or path', 'default')
+        .option('--timeout <ms>', 'Vote timeout in milliseconds', parseInt, 30000)
+        .action(async (files, options) => {
+        const spinner = (0, ora_1.default)('Evaluating files against constitution...').start();
+        try {
+            // Load constitution
+            const loader = (0, loader_1.getDefaultLoader)();
+            let constitution;
+            if (await fs.stat(options.constitution).catch(() => null)) {
+                constitution = loader.loadConstitution(options.constitution);
+            }
+            else {
+                const constitutions = loader.loadConstitutions((0, loader_1.getBaseConstitutionsPath)());
+                const found = constitutions.get(options.constitution);
+                if (!found) {
+                    spinner.fail('Constitution not found');
+                    console.error(chalk_1.default.red(`Constitution not found: ${options.constitution}`));
+                    process.exit(1);
+                }
+                constitution = found;
+            }
+            spinner.text = 'Assembling voting panel...';
+            // Create voting panel
+            const panelConfig = {
+                minPanelSize: options.minAgents,
+                maxPanelSize: Math.max(options.minAgents + 2, 5),
+                consensusMethod: 'weighted-average',
+                timeoutMs: options.timeout,
+                maxRetries: 2,
+                retryDelayMs: 1000,
+                parallelExecution: true
+            };
+            const pool = createAgentPool();
+            const strategy = createVotingStrategy();
+            const orchestrator = new orchestrator_1.VotingOrchestrator(pool, strategy, executeAgentVote);
+            const panelResult = await orchestrator.assemblePanel(panelConfig);
+            spinner.text = `Evaluating with ${panelResult.panel.length} agents...`;
+            // Evaluate each file
+            const findings = [];
+            const allVotes = [];
+            for (const filePath of files) {
+                const absolutePath = path.resolve(filePath);
+                const sourceCode = await fs.readFile(absolutePath, 'utf-8');
+                const language = getLanguageFromExtension(path.extname(absolutePath));
+                // Create evaluation context
+                const context = {
+                    sourceCode,
+                    filePath: absolutePath,
+                    language,
+                    data: {}
+                };
+                // Create voting task for this file
+                const task = {
+                    id: `eval-${Date.now()}-${path.basename(absolutePath)}`,
+                    type: 'constitution-evaluation',
+                    description: `Evaluate ${path.basename(absolutePath)} against ${constitution.id}`,
+                    context: {
+                        constitution: constitution.id,
+                        file: absolutePath,
+                        rules: constitution.rules.length
+                    },
+                    priority: 'high'
+                };
+                // Distribute and collect votes
+                await orchestrator.distributeTask(task, panelResult.panel);
+                const votes = await orchestrator.collectVotes(task.id, options.timeout);
+                // Convert votes to agent votes
+                votes.forEach(vote => {
+                    const agent = panelResult.panel.find(a => a.id === vote.agentId);
+                    if (agent) {
+                        allVotes.push({
+                            agentId: vote.agentId,
+                            agentType: agent.type,
+                            score: vote.score,
+                            confidence: vote.confidence,
+                            reasoning: vote.reasoning,
+                            timestamp: vote.timestamp.toISOString()
+                        });
+                    }
+                });
+                // Evaluate rules with evaluators
+                const evaluators = getEvaluators();
+                for (const rule of constitution.rules) {
+                    if (rule.enabled === false)
+                        continue;
+                    const evaluator = findEvaluatorForCondition(evaluators, rule.condition);
+                    if (!evaluator) {
+                        findings.push({
+                            file: absolutePath,
+                            rule: rule.id,
+                            severity: 'warning',
+                            message: `No evaluator available for rule ${rule.id}`,
+                            passed: true
+                        });
+                        continue;
+                    }
+                    const checkResult = await evaluator.evaluate(rule.condition, context);
+                    findings.push({
+                        file: absolutePath,
+                        rule: rule.id,
+                        severity: rule.severity,
+                        message: checkResult.message || rule.action.message,
+                        passed: checkResult.passed,
+                        actualValue: checkResult.actualValue,
+                        remediation: rule.remediation
+                    });
+                }
+            }
+            spinner.stop();
+            // Generate output
+            const output = {
+                summary: {
+                    verdict: determineVerdict(findings),
+                    constitutionId: constitution.id,
+                    filesEvaluated: files.length,
+                    totalRules: constitution.rules.filter(r => r.enabled !== false).length,
+                    passedRules: findings.filter(f => f.passed).length,
+                    failedRules: findings.filter(f => !f.passed && f.severity === 'error').length,
+                    warnings: findings.filter(f => !f.passed && f.severity === 'warning').length
+                },
+                findings,
+                agentVotes: allVotes,
+                nextSteps: generateNextSteps(findings)
+            };
+            // Display output
+            const format = options.output;
+            displayEvaluationOutput(output, format);
+            // Exit with appropriate code
+            process.exit(output.summary.verdict === 'fail' ? 1 : 0);
+        }
+        catch (error) {
+            spinner.fail('Evaluation failed');
+            console.error(chalk_1.default.red('Error:'), error);
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Display validation results
+ */
+function displayValidationResults(results) {
+    console.log(chalk_1.default.bold('\n📋 Constitution Validation Results\n'));
+    for (const { path: filePath, result, constitution } of results) {
+        const fileName = path.basename(filePath);
+        if (result.valid) {
+            console.log(chalk_1.default.green(`✓ ${fileName}`));
+            if (constitution) {
+                console.log(chalk_1.default.gray(`  ${constitution.name} v${constitution.version}`));
+            }
+        }
+        else {
+            console.log(chalk_1.default.red(`✗ ${fileName}`));
+            if (result.errors.length > 0) {
+                console.log(chalk_1.default.red('\n  Errors:'));
+                result.errors.forEach(err => {
+                    console.log(chalk_1.default.red(`    • ${err.path}: ${err.message}`));
+                    if (err.expected) {
+                        console.log(chalk_1.default.gray(`      Expected: ${err.expected}`));
+                    }
+                });
+            }
+        }
+        if (result.warnings.length > 0) {
+            console.log(chalk_1.default.yellow('\n  Warnings:'));
+            result.warnings.forEach(warn => {
+                console.log(chalk_1.default.yellow(`    • ${warn.path}: ${warn.message}`));
+                if (warn.suggestion) {
+                    console.log(chalk_1.default.gray(`      Suggestion: ${warn.suggestion}`));
+                }
+            });
+        }
+        console.log('');
+    }
+    const totalValid = results.filter(r => r.result.valid).length;
+    const totalInvalid = results.filter(r => !r.result.valid).length;
+    console.log(chalk_1.default.bold('Summary:'));
+    console.log(`  Valid: ${chalk_1.default.green(totalValid)}`);
+    console.log(`  Invalid: ${chalk_1.default.red(totalInvalid)}`);
+    console.log(`  Total: ${results.length}\n`);
+}
+/**
+ * Display constitution list
+ */
+function displayConstitutionList(constitutions, detailed) {
+    console.log(chalk_1.default.bold(`\n📚 Available Constitutions (${constitutions.size})\n`));
+    for (const [id, constitution] of constitutions) {
+        console.log(chalk_1.default.cyan(`${id}`) + chalk_1.default.gray(` (v${constitution.version})`));
+        console.log(`  ${constitution.name}`);
+        console.log(chalk_1.default.gray(`  ${constitution.description}`));
+        if (detailed) {
+            console.log(chalk_1.default.gray(`  Status: ${constitution.metadata.status}`));
+            console.log(chalk_1.default.gray(`  Principles: ${constitution.principles.length}`));
+            console.log(chalk_1.default.gray(`  Rules: ${constitution.rules.length}`));
+            console.log(chalk_1.default.gray(`  Metrics: ${constitution.metrics.length}`));
+            console.log(chalk_1.default.gray(`  Applicable to: ${constitution.metadata.applicableTo.join(', ')}`));
+        }
+        console.log('');
+    }
+}
+/**
+ * Display constitution details
+ */
+function displayConstitutionDetails(constitution) {
+    console.log(chalk_1.default.bold(`\n📜 ${constitution.name}\n`));
+    console.log(`ID: ${chalk_1.default.cyan(constitution.id)}`);
+    console.log(`Version: ${chalk_1.default.cyan(constitution.version)}`);
+    console.log(`Status: ${chalk_1.default.cyan(constitution.metadata.status)}`);
+    console.log(`Description: ${constitution.description}`);
+    console.log('');
+    console.log(chalk_1.default.bold('Principles:'));
+    constitution.principles.forEach(p => {
+        const priorityColor = p.priority === 'critical' ? chalk_1.default.red :
+            p.priority === 'high' ? chalk_1.default.yellow : chalk_1.default.gray;
+        console.log(`  ${priorityColor(p.priority.toUpperCase())} ${p.name}`);
+        console.log(chalk_1.default.gray(`    ${p.description}`));
+    });
+    console.log('');
+    console.log(chalk_1.default.bold('Rules:'));
+    console.log(`  Total: ${constitution.rules.length}`);
+    console.log(`  Enabled: ${constitution.rules.filter(r => r.enabled !== false).length}`);
+    console.log(`  By severity:`);
+    console.log(`    Error: ${constitution.rules.filter(r => r.severity === 'error').length}`);
+    console.log(`    Warning: ${constitution.rules.filter(r => r.severity === 'warning').length}`);
+    console.log(`    Info: ${constitution.rules.filter(r => r.severity === 'info').length}`);
+    console.log('');
+    console.log(chalk_1.default.bold('Metrics:'));
+    constitution.metrics.forEach(m => {
+        console.log(`  ${m.name} (${m.unit})`);
+        if (m.targetValue !== undefined) {
+            console.log(chalk_1.default.gray(`    Target: ${m.targetValue}`));
+        }
+    });
+    console.log('');
+    console.log(chalk_1.default.bold('Metadata:'));
+    console.log(`  Author: ${constitution.metadata.author}`);
+    console.log(`  Created: ${constitution.metadata.createdAt}`);
+    console.log(`  Updated: ${constitution.metadata.updatedAt}`);
+    console.log(`  Applicable to: ${constitution.metadata.applicableTo.join(', ')}`);
+    console.log('');
+}
+/**
+ * Display evaluation output
+ */
+function displayEvaluationOutput(output, format) {
+    if (format === 'json') {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    if (format === 'agent') {
+        // Machine-readable format for agent consumption
+        console.log(JSON.stringify({
+            verdict: output.summary.verdict,
+            constitution: output.summary.constitutionId,
+            passed: output.summary.passedRules,
+            failed: output.summary.failedRules,
+            warnings: output.summary.warnings,
+            nextSteps: output.nextSteps || [],
+            votes: output.agentVotes.map(v => ({
+                agent: v.agentId,
+                score: v.score,
+                confidence: v.confidence
+            }))
+        }));
+        return;
+    }
+    // Human-readable format
+    console.log(chalk_1.default.bold('\n🔍 Constitution Evaluation Results\n'));
+    // Summary
+    const verdictColor = output.summary.verdict === 'pass' ? chalk_1.default.green :
+        output.summary.verdict === 'fail' ? chalk_1.default.red : chalk_1.default.yellow;
+    console.log(chalk_1.default.bold('Verdict: ') + verdictColor(output.summary.verdict.toUpperCase()));
+    console.log(`Constitution: ${chalk_1.default.cyan(output.summary.constitutionId)}`);
+    console.log(`Files Evaluated: ${output.summary.filesEvaluated}`);
+    console.log(`Rules: ${chalk_1.default.green(output.summary.passedRules)} passed, ${chalk_1.default.red(output.summary.failedRules)} failed, ${chalk_1.default.yellow(output.summary.warnings)} warnings`);
+    console.log('');
+    // Findings
+    if (output.findings.length > 0) {
+        const errors = output.findings.filter(f => !f.passed && f.severity === 'error');
+        const warnings = output.findings.filter(f => !f.passed && f.severity === 'warning');
+        if (errors.length > 0) {
+            console.log(chalk_1.default.red.bold('Errors:'));
+            errors.forEach(f => {
+                console.log(chalk_1.default.red(`  ✗ ${f.rule}: ${f.message}`));
+                console.log(chalk_1.default.gray(`    File: ${f.file}`));
+                if (f.actualValue !== undefined) {
+                    console.log(chalk_1.default.gray(`    Actual: ${JSON.stringify(f.actualValue)}`));
+                }
+                if (f.remediation) {
+                    console.log(chalk_1.default.gray(`    Fix: ${f.remediation}`));
+                }
+            });
+            console.log('');
+        }
+        if (warnings.length > 0) {
+            console.log(chalk_1.default.yellow.bold('Warnings:'));
+            warnings.forEach(f => {
+                console.log(chalk_1.default.yellow(`  ⚠ ${f.rule}: ${f.message}`));
+                console.log(chalk_1.default.gray(`    File: ${f.file}`));
+            });
+            console.log('');
+        }
+    }
+    // Agent votes
+    if (output.agentVotes.length > 0) {
+        console.log(chalk_1.default.bold('Agent Votes:'));
+        output.agentVotes.forEach(v => {
+            const scoreColor = v.score >= 0.7 ? chalk_1.default.green :
+                v.score >= 0.4 ? chalk_1.default.yellow : chalk_1.default.red;
+            console.log(`  ${v.agentId} (${v.agentType}): ${scoreColor(v.score.toFixed(2))} confidence ${v.confidence.toFixed(2)}`);
+            console.log(chalk_1.default.gray(`    ${v.reasoning}`));
+        });
+        console.log('');
+    }
+    // Next steps
+    if (output.nextSteps && output.nextSteps.length > 0) {
+        console.log(chalk_1.default.bold('Next Steps:'));
+        output.nextSteps.forEach((step, i) => {
+            console.log(`  ${i + 1}. ${step}`);
+        });
+        console.log('');
+    }
+}
+/**
+ * Helper functions
+ */
+function getEvaluators() {
+    const types = base_1.EvaluatorFactory.getTypes();
+    return types.map(type => base_1.EvaluatorFactory.create(type)).filter((e) => e !== null);
+}
+function findEvaluatorForCondition(evaluators, condition) {
+    return evaluators.find(e => e.canHandle(condition)) || null;
+}
+function getLanguageFromExtension(ext) {
+    const map = {
+        '.ts': 'typescript',
+        '.tsx': 'typescript',
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.py': 'python',
+        '.java': 'java',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.rb': 'ruby'
+    };
+    return map[ext] || 'unknown';
+}
+function determineVerdict(findings) {
+    const hasErrors = findings.some(f => !f.passed && f.severity === 'error');
+    const hasWarnings = findings.some(f => !f.passed && f.severity === 'warning');
+    if (hasErrors)
+        return 'fail';
+    if (hasWarnings)
+        return 'warning';
+    return 'pass';
+}
+function generateNextSteps(findings) {
+    const steps = [];
+    const errors = findings.filter(f => !f.passed && f.severity === 'error');
+    const warnings = findings.filter(f => !f.passed && f.severity === 'warning');
+    if (errors.length > 0) {
+        steps.push(`Fix ${errors.length} critical error${errors.length > 1 ? 's' : ''}`);
+        errors.forEach(e => {
+            if (e.remediation) {
+                steps.push(`  - ${e.rule}: ${e.remediation}`);
+            }
+        });
+    }
+    if (warnings.length > 0) {
+        steps.push(`Address ${warnings.length} warning${warnings.length > 1 ? 's' : ''} to improve quality`);
+    }
+    if (errors.length === 0 && warnings.length === 0) {
+        steps.push('All checks passed - ready for next stage');
+    }
+    return steps;
+}
+/**
+ * Create agent pool for voting
+ */
+function createAgentPool() {
+    const agents = [
+        { id: 'test-gen-1', type: 'test-generator', expertise: ['unit-testing', 'integration'], weight: 1.0 },
+        { id: 'coverage-1', type: 'coverage-analyzer', expertise: ['code-coverage', 'gap-analysis'], weight: 1.2 },
+        { id: 'quality-gate-1', type: 'quality-gate', expertise: ['quality-metrics', 'thresholds'], weight: 1.5 },
+        { id: 'security-1', type: 'security-scanner', expertise: ['security', 'vulnerabilities'], weight: 1.3 },
+        { id: 'performance-1', type: 'performance-tester', expertise: ['performance', 'benchmarks'], weight: 1.1 }
+    ];
+    const pool = {
+        available: [...agents],
+        busy: new Map(),
+        failed: new Set(),
+        getAvailable(expertise) {
+            return this.available.filter(a => {
+                if (this.busy.has(a.id) || this.failed.has(a.id))
+                    return false;
+                if (!expertise || expertise.length === 0)
+                    return true;
+                return expertise.some(e => a.expertise.includes(e));
+            });
+        },
+        reserve(agentId, task) {
+            this.busy.set(agentId, task);
+        },
+        release(agentId) {
+            this.busy.delete(agentId);
+        },
+        markFailed(agentId) {
+            this.failed.add(agentId);
+            this.busy.delete(agentId);
+        },
+        restore(agentId) {
+            this.failed.delete(agentId);
+        }
+    };
+    return pool;
+}
+/**
+ * Create voting strategy
+ */
+function createVotingStrategy() {
+    return {
+        selectAgents(pool, task, config) {
+            const available = pool.getAvailable(task.requiredExpertise);
+            const selected = available.slice(0, config.maxPanelSize);
+            return selected;
+        },
+        calculateWeight(agent, task) {
+            // Calculate weight based on expertise match
+            const expertiseMatch = task.requiredExpertise
+                ? task.requiredExpertise.filter(e => agent.expertise.includes(e)).length / task.requiredExpertise.length
+                : 1.0;
+            return agent.weight * (0.5 + expertiseMatch * 0.5);
+        },
+        shouldRetry(agent, task, attempt, error) {
+            return attempt <= 2; // Max 2 retries
+        },
+        adjustTimeout(baseTimeout, attempt, systemLoad) {
+            return baseTimeout * (1 + attempt * 0.5) * (1 + systemLoad * 0.3);
+        }
+    };
+}
+/**
+ * Execute agent vote (mock implementation for CLI)
+ */
+async function executeAgentVote(agent, task) {
+    // Simulate agent evaluation
+    await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 500));
+    // Generate score based on agent expertise match
+    const expertiseMatch = task.requiredExpertise
+        ? task.requiredExpertise.filter(e => agent.expertise.includes(e)).length / task.requiredExpertise.length
+        : 1.0;
+    const score = 0.5 + (expertiseMatch * 0.3) + (Math.random() * 0.2);
+    const confidence = 0.7 + (Math.random() * 0.3);
+    return {
+        agentId: agent.id,
+        taskId: task.id,
+        score: Math.min(1.0, score),
+        confidence: Math.min(1.0, confidence),
+        reasoning: `Evaluated based on ${agent.expertise.join(', ')} expertise`,
+        timestamp: new Date(),
+        metadata: { agentType: agent.type, weight: agent.weight }
+    };
+}
+/**
+ * Create main constitution command
+ */
+function createConstitutionCommand() {
+    const command = new commander_1.Command('constitution')
+        .description('Manage and evaluate quality constitutions');
+    command.addCommand(createConstitutionValidateCommand());
+    command.addCommand(createConstitutionListCommand());
+    command.addCommand(createConstitutionShowCommand());
+    command.addCommand(createConstitutionEvaluateCommand());
+    return command;
+}
+//# sourceMappingURL=constitution.js.map