@evolith/smart-cli 0.0.3-beta → 1.1.1

package/dist/commands/init/agents.command.js

@@ -1,43 +1,10 @@
 "use strict";
-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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -46,10 +13,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentsCommand = void 0;
+const prompt_service_1 = require("../../infrastructure/prompts/prompt.service");
 const nest_commander_1 = require("nest-commander");
-const p = __importStar(require("@clack/prompts"));
 const chalk_1 = __importDefault(require("chalk"));
-const tool_utils_1 = require("../../core/mcp/tools/tool-utils");
+const node_filesystem_provider_1 = require("../../infrastructure/providers/node-filesystem.provider");
+const agent_registry_service_1 = require("../../infrastructure/adapters/agent-registry.service");
+const agent_ruleset_builder_1 = require("@evolith/core-domain/application/agents/agent-ruleset-builder");
+const base_command_1 = require("../../infrastructure/cli/base-command");
+let cachedFileSystem = null;
+function getFileSystem() {
+    if (!cachedFileSystem) {
+        cachedFileSystem = new node_filesystem_provider_1.NodeFileSystemProvider().createFileSystem();
+    }
+    return cachedFileSystem;
+}
 const AGENT_TEMPLATES = [
     {
         value: 'standard',
@@ -79,8 +56,12 @@ const AVAILABLE_RULESETS = [
     { value: 'open-core', label: 'Open-Core Boundary Rules', selected: true },
     { value: 'inheritance', label: 'Inheritance Rules', selected: true },
 ];
-let AgentsCommand = class AgentsCommand extends nest_commander_1.CommandRunner {
-    async run(passedParam, options) {
+let AgentsCommand = class AgentsCommand extends base_command_1.BaseEvolithCommand {
+    constructor(promptService) {
+        super('AgentsCommand', promptService);
+        this.registry = new agent_registry_service_1.AgentRegistryService(getFileSystem());
+    }
+    async executeCommand(passedParam, options) {
         const action = passedParam[0] || 'menu';
         console.clear();
         switch (action) {
@@ -106,8 +87,8 @@ let AgentsCommand = class AgentsCommand extends nest_commander_1.CommandRunner {
         }
     }
     async showMenu() {
-        p.intro(chalk_1.default.bgCyan.white.bold(' Evolith SDK - Agent Management '));
-        const selection = await p.select({
+        this.promptService.showIntro('Evolith SDK - Agent Management');
+        const selection = await this.promptService.select({
             message: 'Select an action:',
             options: [
                 { value: 'install', label: 'Install New Agent', hint: 'Create a new agent with template and rulesets' },
@@ -119,7 +100,7 @@ let AgentsCommand = class AgentsCommand extends nest_commander_1.CommandRunner {
             ],
         });
         if (selection === 'exit') {
-            p.outro(chalk_1.default.blue('Agent management closed.'));
+            this.promptService.showOutro(chalk_1.default.blue('Agent management closed.'));
             return;
         }
         switch (selection) {
@@ -141,354 +122,200 @@ let AgentsCommand = class AgentsCommand extends nest_commander_1.CommandRunner {
         }
     }
     async installAgent(_options) {
-        p.intro(chalk_1.default.bgGreen.white.bold(' Evolith SDK - Agent Installation '));
-        const agentInfo = await p.group({
-            name: () => p.text({
-                message: 'Agent name (kebab-case, e.g., my-agent):',
-                placeholder: 'my-agent',
-                validate: (value) => {
-                    if (!value)
-                        return 'Agent name is required';
-                    if (value.includes(' '))
-                        return 'Name cannot contain spaces';
-                    if (!/^[a-z0-9-]+$/.test(value))
-                        return 'Use lowercase letters, numbers, and hyphens only';
-                },
-            }),
-            template: () => p.select({
-                message: 'Select agent template:',
-                options: AGENT_TEMPLATES,
-            }),
-            description: () => p.text({
-                message: 'Agent description (optional):',
-                placeholder: 'Agent for handling specific governance tasks',
-            }),
-            adrs: () => p.multiselect({
-                message: 'Select ADR rulesets to include:',
-                options: AVAILABLE_ADRS,
-                required: false,
-            }),
-            rulesets: () => p.multiselect({
-                message: 'Select additional rulesets:',
-                options: AVAILABLE_RULESETS,
-                required: false,
-            }),
-            confirmInstall: () => p.confirm({
-                message: 'Ready to install agent?',
-                initialValue: true,
-            }),
-        }, {
-            onCancel: () => {
-                p.cancel('Installation cancelled.');
-                process.exit(0);
+        this.promptService.showIntro('Evolith SDK - Agent Installation');
+        const name = await this.promptService.text({
+            message: 'Agent name (kebab-case, e.g., my-agent):',
+            placeholder: 'my-agent',
+            validate: (value) => {
+                if (!value)
+                    return 'Agent name is required';
+                if (value.includes(' '))
+                    return 'Name cannot contain spaces';
+                if (!/^[a-z0-9-]+$/.test(value))
+                    return 'Use lowercase letters, numbers, and hyphens only';
             },
         });
-        if (!agentInfo.confirmInstall) {
-            p.outro(chalk_1.default.yellow('Installation cancelled.'));
-            return;
-        }
-        const fs = (0, tool_utils_1.getFileSystem)();
-        const agentDir = `${process.cwd()}/rulesets/agents/${agentInfo.name}`;
-        const rulesetPath = `${agentDir}/agent.rules.json`;
-        await fs.ensureDir(agentDir);
-        const agentRuleset = this.buildAgentRuleset(agentInfo);
-        await fs.writeJson(rulesetPath, agentRuleset);
-        const configPath = `${agentDir}/agent.config.json`;
-        await fs.writeJson(configPath, {
-            name: agentInfo.name,
-            template: agentInfo.template,
-            description: agentInfo.description || '',
-            adrs: agentInfo.adrs,
-            rulesets: agentInfo.rulesets,
-            installedAt: new Date().toISOString(),
-            version: '1.0.0',
+        const template = await this.promptService.select({
+            message: 'Select agent template:',
+            options: AGENT_TEMPLATES,
         });
-        p.log.success(chalk_1.default.green(`\n✓ Agent '${agentInfo.name}' installed successfully`));
-        p.note(`Ruleset: ${rulesetPath}`, 'Location');
-        p.note(`Config: ${configPath}`, 'Location');
-        const nextSteps = `Next steps:
-  1. Review agent rules: cat ${rulesetPath}
-  2. Validate agent: evolith agents validate
-  3. Update documentation if needed`;
-        p.note(nextSteps, 'Next Steps');
-        p.outro(chalk_1.default.green('Agent installation complete.'));
-    }
-    buildAgentRuleset(agentInfo) {
-        const principles = [];
-        principles.push({
-            id: 'AGT-01',
-            principle: 'Agent Identity',
-            statement: `Agent ${agentInfo.name} enforces Evolith governance standards`,
-            severity: 'MUST',
-            blocking: true,
+        const description = await this.promptService.text({
+            message: 'Agent description (optional):',
+            placeholder: 'Agent for handling specific governance tasks',
         });
-        if (agentInfo.template === 'enterprise') {
-            principles.push({
-                id: 'AGT-02',
-                principle: 'Audit Trail',
-                statement: 'All agent actions must be logged for traceability',
-                severity: 'MUST',
-                blocking: true,
-            });
-            principles.push({
-                id: 'AGT-03',
-                principle: 'Approval Chain',
-                statement: 'Critical actions require explicit approval',
-                severity: 'SHOULD',
-                blocking: false,
-            });
-        }
-        if (agentInfo.adrs.includes('adr-0002')) {
-            principles.push({
-                id: 'AGT-HXA-01',
-                principle: 'Hexagonal Architecture Compliance',
-                statement: 'Domain layer has zero framework dependencies',
-                severity: 'MUST',
-                blocking: true,
-            });
-        }
-        if (agentInfo.adrs.includes('adr-0018')) {
-            principles.push({
-                id: 'AGT-TP-01',
-                principle: 'Testing Pyramid',
-                statement: '70% unit / 20% integration / 10% E2E distribution',
-                severity: 'SHOULD',
-                blocking: false,
-            });
-        }
-        if (agentInfo.rulesets.includes('acl')) {
-            principles.push({
-                id: 'AGT-ACL-01',
-                principle: 'Schema Validation',
-                statement: 'All external data validated before ingestion',
-                severity: 'MUST',
-                blocking: true,
-            });
+        const adrs = await this.promptService.multiselect({
+            message: 'Select ADR rulesets to include:',
+            options: AVAILABLE_ADRS,
+            required: false,
+        });
+        const rulesets = await this.promptService.multiselect({
+            message: 'Select additional rulesets:',
+            options: AVAILABLE_RULESETS,
+            required: false,
+        });
+        const confirmInstall = await this.promptService.confirm('Ready to install agent?', true);
+        if (!confirmInstall) {
+            this.promptService.showOutro(chalk_1.default.yellow('Installation cancelled.'));
+            return;
         }
-        return {
-            agent: {
-                name: agentInfo.name,
-                template: agentInfo.template,
-                version: '1.0.0',
-                installedAt: new Date().toISOString(),
-            },
-            ruleset: {
-                version: '1.0',
-                type: 'agent',
-                scope: 'governance',
-            },
-            principles,
-            metadata: {
-                adrs: agentInfo.adrs,
-                rulesets: agentInfo.rulesets,
-            },
+        const rulesetContent = (0, agent_ruleset_builder_1.buildAgentRuleset)({
+            name,
+            template,
+            adrs,
+            rulesets,
+        });
+        const config = {
+            name,
+            version: '1.0.0',
+            template,
+            description,
+            adrs,
+            rulesets,
+            rulesetFiles: ['agent.rules.json'],
+            installedAt: new Date().toISOString()
         };
+        await this.registry.installAgent(process.cwd(), config, rulesetContent);
+        this.promptService.showSuccess(`\n✓ Agent '${name}' installed successfully`);
+        this.promptService.showInfo(`Next steps:\n  1. Review agent rules\n  2. Validate agent: evolith agents validate`);
+        this.promptService.showOutro(chalk_1.default.green('Agent installation complete.'));
     }
     async listAgents(_options) {
-        p.intro(chalk_1.default.bgBlue.white.bold(' Evolith SDK - Agent List '));
-        const fs = (0, tool_utils_1.getFileSystem)();
-        const agentsDir = `${process.cwd()}/rulesets/agents`;
-        if (!await fs.exists(agentsDir)) {
-            p.log.warn('No agents directory found.');
-            p.log.info('Run "evolith agents install" to install your first agent.');
-            return;
-        }
-        const entries = await fs.readdirNames(agentsDir);
-        if (entries.length === 0) {
-            p.log.warn('No agents installed.');
-            p.log.info('Run "evolith agents install" to install your first agent.');
+        this.promptService.showIntro('Evolith SDK - Agent List');
+        const agents = await this.registry.discover(process.cwd());
+        if (agents.length === 0) {
+            this.promptService.showWarning('No agents installed.');
+            this.promptService.showInfo('Run "evolith agents install" to install your first agent.');
             return;
         }
-        p.log.info(`Found ${entries.length} installed agent(s):\n`);
-        for (const agentName of entries) {
-            const configPath = `${agentsDir}/${agentName}/agent.config.json`;
-            const rulesetPath = `${agentsDir}/${agentName}/agent.rules.json`;
-            let config = {};
-            let ruleset = {};
-            if (await fs.exists(configPath)) {
-                config = await fs.readJson(configPath);
-            }
-            if (await fs.exists(rulesetPath)) {
-                ruleset = await fs.readJson(rulesetPath);
-            }
-            const version = config.version || 'unknown';
-            const template = config.template || 'standard';
-            const principles = ruleset.principles || [];
-            p.log.info(chalk_1.default.cyan(`  • ${agentName}`));
-            p.log.info(chalk_1.default.gray(`    Version: ${version} | Template: ${template} | Rules: ${principles.length}`));
+        this.promptService.showInfo(`Found ${agents.length} installed agent(s):\n`);
+        for (const agent of agents) {
+            const _principlesCount = 0;
+            this.promptService.showInfo(chalk_1.default.cyan(`  • ${agent.name}`));
+            this.promptService.showInfo(chalk_1.default.gray(`    Version: ${agent.version} | Template: ${agent.template}`));
         }
-        p.outro(chalk_1.default.green(`\n${entries.length} agent(s) found.`));
+        this.promptService.showOutro(chalk_1.default.green(`\n${agents.length} agent(s) found.`));
     }
     async validateAgent(_options) {
-        p.intro(chalk_1.default.bgYellow.white.bold(' Evolith SDK - Agent Validation '));
-        const fs = (0, tool_utils_1.getFileSystem)();
-        const agentsDir = `${process.cwd()}/rulesets/agents`;
-        if (!await fs.exists(agentsDir)) {
-            p.log.error('No agents directory found.');
+        this.promptService.showIntro('Evolith SDK - Agent Validation');
+        const agents = await this.registry.discover(process.cwd());
+        if (agents.length === 0) {
+            this.promptService.showWarning('No agents installed to validate.');
             return;
         }
-        const entries = await fs.readdirNames(agentsDir);
-        if (entries.length === 0) {
-            p.log.warn('No agents installed to validate.');
-            return;
-        }
-        const agentToValidate = await p.select({
+        const agentToValidate = await this.promptService.select({
             message: 'Select agent to validate:',
-            options: entries.map(name => ({ value: name, label: name })),
+            options: agents.map(a => ({ value: a.name, label: a.name })),
         });
-        const rulesetPath = `${agentsDir}/${String(agentToValidate)}/agent.rules.json`;
+        this.promptService.showInfo('\nValidating agent ruleset against engine...\n');
+        const fs = getFileSystem();
+        const rulesetPath = `${process.cwd()}/rulesets/agents/${String(agentToValidate)}/agent.rules.json`;
         if (!await fs.exists(rulesetPath)) {
-            p.log.error(`Agent ruleset not found: ${rulesetPath}`);
+            this.promptService.showError(`Ruleset file not found: ${rulesetPath}`);
             return;
         }
         const ruleset = await fs.readJson(rulesetPath);
-        p.log.info('\nValidating agent ruleset...\n');
         const issues = [];
-        if (!ruleset.agent?.name) {
+        if (!ruleset.agent?.name)
             issues.push({ field: 'agent.name', message: 'Agent name is required' });
-        }
-        if (!ruleset.ruleset?.version) {
+        if (!ruleset.ruleset?.version)
             issues.push({ field: 'ruleset.version', message: 'Ruleset version is required' });
-        }
-        if (!ruleset.principles || ruleset.principles.length === 0) {
+        if (!ruleset.principles || ruleset.principles.length === 0)
             issues.push({ field: 'principles', message: 'At least one principle is required' });
-        }
         for (const principle of ruleset.principles || []) {
-            if (!principle.id) {
+            if (!principle.id)
                 issues.push({ field: `principle.missing-id`, message: `Principle "${principle.principle}" missing ID` });
-            }
-            if (!principle.severity) {
+            if (!principle.severity)
                 issues.push({ field: `principle.missing-severity`, message: `Principle "${principle.id}" missing severity` });
-            }
         }
         if (issues.length === 0) {
-            p.log.success(chalk_1.default.green('\n✓ Agent validation passed'));
-            p.log.info(`Agent: ${ruleset.agent?.name}`);
-            p.log.info(`Rules: ${ruleset.principles?.length} principles`);
-            p.log.info(`MUST rules: ${ruleset.principles?.filter(p => p.severity === 'MUST').length}`);
-            p.log.info(`SHOULD rules: ${ruleset.principles?.filter(p => p.severity === 'SHOULD').length}`);
+            await this.registry.updateLastValidated(process.cwd(), String(agentToValidate));
+            this.promptService.showSuccess('\n✓ Agent validation passed');
         }
         else {
-            p.log.error(chalk_1.default.red(`\n✗ Agent validation failed: ${issues.length} issue(s) found`));
+            this.promptService.showError(`\n✗ Agent validation failed: ${issues.length} issue(s) found`);
             for (const issue of issues) {
-                p.log.error(`  - [${issue.field}] ${issue.message}`);
+                this.promptService.showError(`  - [${issue.field}] ${issue.message}`);
             }
         }
-        p.outro(issues.length === 0 ? chalk_1.default.green('Validation complete.') : chalk_1.default.red('Validation complete with errors.'));
+        this.promptService.showOutro(issues.length === 0 ? chalk_1.default.green('Validation complete.') : chalk_1.default.red('Validation complete with errors.'));
     }
     async removeAgent(_options) {
-        p.intro(chalk_1.default.bgRed.white.bold(' Evolith SDK - Agent Removal '));
-        const fs = (0, tool_utils_1.getFileSystem)();
-        const agentsDir = `${process.cwd()}/rulesets/agents`;
-        if (!await fs.exists(agentsDir)) {
-            p.log.error('No agents directory found.');
-            return;
-        }
-        const entries = await fs.readdirNames(agentsDir);
-        if (entries.length === 0) {
-            p.log.warn('No agents installed to remove.');
+        this.promptService.showIntro('Evolith SDK - Agent Removal');
+        const agents = await this.registry.discover(process.cwd());
+        if (agents.length === 0) {
+            this.promptService.showWarning('No agents installed to remove.');
             return;
         }
-        const agentToRemove = await p.select({
+        const agentToRemove = await this.promptService.select({
             message: 'Select agent to remove:',
-            options: entries.map(name => ({ value: name, label: name })),
-        });
-        const confirm = await p.confirm({
-            message: `Are you sure you want to remove agent '${String(agentToRemove)}'? This cannot be undone.`,
-            initialValue: false,
+            options: agents.map(a => ({ value: a.name, label: a.name })),
         });
+        const confirm = await this.promptService.confirm(`Are you sure you want to remove agent '${String(agentToRemove)}'? This cannot be undone.`, false);
         if (!confirm) {
-            p.outro(chalk_1.default.yellow('Removal cancelled.'));
+            this.promptService.showOutro(chalk_1.default.yellow('Removal cancelled.'));
             return;
         }
-        const agentPath = `${agentsDir}/${String(agentToRemove)}`;
-        await fs.remove(agentPath);
-        p.log.success(chalk_1.default.green(`\n✓ Agent '${String(agentToRemove)}' removed successfully`));
-        p.outro(chalk_1.default.green('Agent removal complete.'));
+        await this.registry.unregister(process.cwd(), String(agentToRemove));
+        this.promptService.showSuccess(`\n✓ Agent '${String(agentToRemove)}' removed successfully`);
+        this.promptService.showOutro(chalk_1.default.green('Agent removal complete.'));
     }
     async upgradeAgent(_options) {
-        p.intro(chalk_1.default.bgMagenta.white.bold(' Evolith SDK - Agent Upgrade '));
-        const fs = (0, tool_utils_1.getFileSystem)();
-        const agentsDir = `${process.cwd()}/rulesets/agents`;
-        if (!await fs.exists(agentsDir)) {
-            p.log.error('No agents directory found.');
-            return;
-        }
-        const entries = await fs.readdirNames(agentsDir);
-        if (entries.length === 0) {
-            p.log.warn('No agents installed to upgrade.');
+        this.promptService.showIntro('Evolith SDK - Agent Upgrade');
+        const agents = await this.registry.discover(process.cwd());
+        if (agents.length === 0) {
+            this.promptService.showWarning('No agents installed to upgrade.');
             return;
         }
-        const agentToUpgrade = await p.select({
+        const agentName = await this.promptService.select({
             message: 'Select agent to upgrade:',
-            options: entries.map(name => ({ value: name, label: name })),
+            options: agents.map(a => ({ value: a.name, label: a.name })),
         });
-        const rulesetPath = `${agentsDir}/${String(agentToUpgrade)}/agent.rules.json`;
-        const configPath = `${agentsDir}/${String(agentToUpgrade)}/agent.config.json`;
+        const agent = await this.registry.getAgent(process.cwd(), String(agentName));
+        if (!agent)
+            return;
+        const fs = getFileSystem();
+        const rulesetPath = `${process.cwd()}/rulesets/agents/${agent.name}/agent.rules.json`;
         if (!await fs.exists(rulesetPath)) {
-            p.log.error(`Agent ruleset not found: ${rulesetPath}`);
+            this.promptService.showError('Agent ruleset not found');
             return;
         }
         const ruleset = await fs.readJson(rulesetPath);
-        const config = await fs.readJson(configPath);
-        const currentVersion = ruleset.agent?.version || '1.0.0';
-        const parts = currentVersion.split('.').map(Number);
+        const parts = agent.version.split('.').map(Number);
         parts[2]++;
         const newVersion = parts.join('.');
-        ruleset.agent.version = newVersion;
-        await fs.writeJson(rulesetPath, ruleset);
-        config.version = newVersion;
-        config.upgradedAt = new Date().toISOString();
-        await fs.writeJson(configPath, config);
-        p.log.success(chalk_1.default.green(`\n✓ Agent '${String(agentToUpgrade)}' upgraded: ${currentVersion} → ${newVersion}`));
-        p.outro(chalk_1.default.green('Agent upgrade complete.'));
-    }
-    parseInstall(val) {
-        return val;
-    }
-    parseRemove(val) {
-        return val;
-    }
-    parseList() {
-        return true;
-    }
-    parseDryRun() {
-        return true;
+        agent.version = newVersion;
+        if (ruleset.agent)
+            ruleset.agent.version = newVersion;
+        await this.registry.updateAgent(process.cwd(), agent.name, agent, ruleset);
+        this.promptService.showSuccess(`\n✓ Agent '${agent.name}' upgraded: ${parts.join('.')} → ${newVersion}`);
+        this.promptService.showOutro(chalk_1.default.green('Agent upgrade complete.'));
     }
+    parseInstall(val) { return val; }
+    parseRemove(val) { return val; }
+    parseList() { return true; }
+    parseDryRun() { return true; }
 };
 exports.AgentsCommand = AgentsCommand;
 __decorate([
-    (0, nest_commander_1.Option)({
-        flags: '-i, --install [name]',
-        description: 'Install a new agent with specified name',
-    }),
+    (0, nest_commander_1.Option)({ flags: '-i, --install [name]', description: 'Install a new agent' }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", String)
 ], AgentsCommand.prototype, "parseInstall", null);
 __decorate([
-    (0, nest_commander_1.Option)({
-        flags: '-r, --remove [name]',
-        description: 'Remove an agent by name',
-    }),
+    (0, nest_commander_1.Option)({ flags: '-r, --remove [name]', description: 'Remove an agent' }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", String)
 ], AgentsCommand.prototype, "parseRemove", null);
 __decorate([
-    (0, nest_commander_1.Option)({
-        flags: '-l, --list',
-        description: 'List installed agents',
-    }),
+    (0, nest_commander_1.Option)({ flags: '-l, --list', description: 'List installed agents' }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Boolean)
 ], AgentsCommand.prototype, "parseList", null);
 __decorate([
-    (0, nest_commander_1.Option)({
-        flags: '-d, --dry-run',
-        description: 'Execute in simulation mode without altering files',
-    }),
+    (0, nest_commander_1.Option)({ flags: '-d, --dry-run', description: 'Dry run' }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Boolean)
@@ -497,6 +324,7 @@ exports.AgentsCommand = AgentsCommand = __decorate([
     (0, nest_commander_1.Command)({
         name: 'agents',
         description: 'Instala, lista, valida o remueve agentes de Evolith en el repositorio satélite',
-    })
+    }),
+    __metadata("design:paramtypes", [prompt_service_1.PromptService])
 ], AgentsCommand);
 //# sourceMappingURL=agents.command.js.map