suzi-cli 0.1.13 → 0.1.14

package/dist/commands/agent.js

@@ -0,0 +1,991 @@
+"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 __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.registerAgentCommand = registerAgentCommand;
+exports.listAgentsCommand = listAgentsCommand;
+exports.viewAgentCommand = viewAgentCommand;
+exports.deployAgentCommand = deployAgentCommand;
+exports.validateAgentCommand = validateAgentCommand;
+exports.activateAgentCommand = activateAgentCommand;
+exports.deactivateAgentCommand = deactivateAgentCommand;
+exports.executeAgentCommand = executeAgentCommand;
+exports.logsAgentCommand = logsAgentCommand;
+exports.codeAgentCommand = codeAgentCommand;
+exports.deleteAgentCommand = deleteAgentCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("../lib/api");
+const ui_1 = require("../utils/ui");
+const memory_1 = require("../lib/memory");
+const tty_1 = require("../utils/tty");
+const agent_picker_1 = require("../utils/agent-picker");
+function registerAgentCommand(program) {
+    const agent = program
+        .command('agents')
+        .description('Manage agents (list, view, deploy, activate, execute, logs, etc.)');
+    // suzi agents (default: list)
+    agent
+        .action(async (opts) => {
+        // Default action is list
+        await listAgentsCommand(opts);
+    });
+    // suzi agents list
+    agent
+        .command('list')
+        .description('List all agents')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        await listAgentsCommand(opts);
+    });
+    // suzi agents view [id]
+    agent
+        .command('view [id]')
+        .description('View agent details')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        await viewAgentCommand(id, opts);
+    });
+    // suzi agents deploy [file]
+    agent
+        .command('deploy [file]')
+        .description('Deploy an agent from a TypeScript file')
+        .option('-t, --title <title>', 'Agent title')
+        .option('-d, --description <desc>', 'Agent description')
+        .option('--update <agentId>', 'Update an existing agent instead of creating new')
+        .option('--activate', 'Activate the agent after deploying')
+        .option('--json', 'Output as JSON')
+        .action(async (file, opts) => {
+        await deployAgentCommand(file, opts);
+    });
+    // suzi agents validate [file]
+    agent
+        .command('validate [file]')
+        .description('Validate an agent TypeScript file without deploying')
+        .option('--json', 'Output as JSON')
+        .action(async (file, opts) => {
+        await validateAgentCommand(file, opts);
+    });
+    // suzi agents run <action>
+    agent
+        .command('run <action>')
+        .description('Execute an action directly (e.g. suzi agents run polymarket.get_market_price --tokenID 0x123)')
+        .allowUnknownOption()
+        .allowExcessArguments(true)
+        .option('--json-params <params>', 'Pass all parameters as a JSON string')
+        .option('--output <format>', 'Output format: pretty (default) or json', 'pretty')
+        .option('--dry-run', 'Preview the request payload without executing')
+        .action(async (action, opts) => {
+        // Delegate to existing run command logic
+        const { registerRunCommand } = await Promise.resolve().then(() => __importStar(require('./run')));
+        const tempProgram = new commander_1.Command();
+        registerRunCommand(tempProgram);
+        // Re-parse args for run command
+        const runArgs = ['node', 'suzi', 'run', action, ...process.argv.slice(process.argv.indexOf(action) + 1)];
+        await tempProgram.parseAsync(runArgs);
+    });
+    // suzi agents activate [id]
+    agent
+        .command('activate [id]')
+        .description('Activate an agent')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        await activateAgentCommand(id, opts);
+    });
+    // suzi agents deactivate [id]
+    agent
+        .command('deactivate [id]')
+        .description('Deactivate an agent (stops execution)')
+        .option('-f, --force', 'Skip confirmation')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        await deactivateAgentCommand(id, opts);
+    });
+    // suzi agents execute [id]
+    agent
+        .command('execute [id] [trigger]')
+        .description('Manually execute an agent trigger')
+        .option('--json', 'Output as JSON')
+        .action(async (id, trigger, opts) => {
+        await executeAgentCommand(id, trigger, opts);
+    });
+    // suzi agents logs [id]
+    agent
+        .command('logs [id]')
+        .description('View agent logs')
+        .option('-n, --limit <n>', 'Number of log entries', '20')
+        .option('--level <level>', 'Filter by level (info|warn|error|debug)')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        await logsAgentCommand(id, opts);
+    });
+    // suzi agents code [id]
+    agent
+        .command('code [id]')
+        .description('View agent source code')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        await codeAgentCommand(id, opts);
+    });
+    // suzi agents delete [id]
+    agent
+        .command('delete [id]')
+        .description('Delete an agent')
+        .option('-f, --force', 'Skip confirmation')
+        .option('--json', 'Output as JSON')
+        .action(async (id, opts) => {
+        await deleteAgentCommand(id, opts);
+    });
+}
+// ============================================================================
+// Command Implementations
+// ============================================================================
+async function listAgentsCommand(opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const spinner = (0, tty_1.createSpinner)('Loading agents...', jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.get)('/api/agent?limit=50');
+    if (!resp.ok) {
+        spinner?.fail();
+        const msg = `Failed to load agents: ${resp.data?.error || 'Unknown error'}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    spinner?.stop();
+    const agentList = resp.data.agents || [];
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { agents: agentList, count: agentList.length } });
+        return;
+    }
+    if (agentList.length === 0) {
+        (0, ui_1.header)('Agents');
+        console.log();
+        (0, ui_1.info)('No agents found. Create one with `suzi agents deploy <file>`.');
+        return;
+    }
+    (0, ui_1.header)(`Agents (${agentList.length})`);
+    console.log();
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.gray('#'),
+            chalk_1.default.gray('Name'),
+            chalk_1.default.gray('Status'),
+            chalk_1.default.gray('ID'),
+            chalk_1.default.gray('Created'),
+        ],
+        style: { head: [], border: ['gray'] },
+    });
+    for (let i = 0; i < agentList.length; i++) {
+        const agent = agentList[i];
+        table.push([
+            ui_1.colors.muted(String(i + 1)),
+            chalk_1.default.bold(agent.title || 'Untitled'),
+            (0, ui_1.statusBadge)(agent.status),
+            agent.id,
+            ui_1.colors.muted(new Date(agent.createdAt).toLocaleDateString()),
+        ]);
+    }
+    console.log(table.toString());
+}
+async function viewAgentCommand(idOrName, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    // Fetch full details
+    const spinner = (0, tty_1.createSpinner)('Loading agent details...', jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.get)(`/api/agent/${agent.id}`);
+    if (!resp.ok) {
+        spinner?.fail();
+        const msg = `Failed to load agent: ${resp.data?.error || 'Unknown error'}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    spinner?.stop();
+    const fullAgent = resp.data;
+    // Fetch resources
+    const resResp = await (0, api_1.get)(`/api/agent/${agent.id}/resources`);
+    const resources = resResp.ok ? resResp.data?.resources || [] : [];
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { agent: fullAgent, resources } });
+        return;
+    }
+    // Pretty output
+    (0, ui_1.header)(fullAgent.title || 'Untitled Agent');
+    console.log();
+    (0, ui_1.label)('ID', fullAgent.id);
+    (0, ui_1.label)('Status', (0, ui_1.statusBadge)(fullAgent.status));
+    (0, ui_1.label)('Description', fullAgent.description || ui_1.colors.muted('None'));
+    (0, ui_1.label)('Created', new Date(fullAgent.createdAt).toLocaleString());
+    (0, ui_1.label)('Updated', new Date(fullAgent.updatedAt).toLocaleString());
+    // Show spec info
+    if (fullAgent.spec) {
+        const spec = (0, ui_1.safeParseJSON)(fullAgent.spec);
+        console.log();
+        console.log(ui_1.colors.muted('  Agent Spec:'));
+        if (spec.meta) {
+            (0, ui_1.label)('  Version', spec.meta.version || 'N/A');
+        }
+        if (spec.triggers) {
+            const triggerNames = Object.keys(spec.triggers);
+            (0, ui_1.label)('  Triggers', triggerNames.join(', ') || 'None');
+        }
+        if (spec.resources) {
+            const resourceTypes = Object.entries(spec.resources)
+                .map(([key, val]) => {
+                const type = typeof val === 'string' ? val : (val?.type || 'unknown');
+                return `${key}(${type})`;
+            })
+                .join(', ');
+            (0, ui_1.label)('  Resources', resourceTypes || 'None');
+        }
+    }
+    // Show resources
+    if (resources.length > 0) {
+        console.log();
+        console.log(ui_1.colors.muted('  Wallet Resources:'));
+        for (const res of resources) {
+            (0, ui_1.label)(`  ${res.walletType.toUpperCase()}`, res.address || 'N/A');
+        }
+    }
+    console.log();
+    (0, ui_1.divider)();
+}
+async function deployAgentCommand(file, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    // Find the agent file
+    let filePath = file;
+    if (!filePath) {
+        // Look for common agent file patterns in current directory
+        const candidates = [
+            'agent.ts',
+            'src/agent.ts',
+            'index.ts',
+            'src/index.ts',
+        ];
+        for (const candidate of candidates) {
+            const resolved = path_1.default.resolve(process.cwd(), candidate);
+            if (fs_1.default.existsSync(resolved)) {
+                filePath = resolved;
+                break;
+            }
+        }
+        if (!filePath) {
+            const msg = 'No agent file found. Specify a file path.';
+            if (jsonMode) {
+                (0, tty_1.outputJson)({ success: false, error: msg });
+            }
+            else {
+                (0, ui_1.error)(msg);
+                (0, ui_1.info)('Looked for: ' + candidates.join(', '));
+            }
+            return;
+        }
+    }
+    const resolvedPath = path_1.default.resolve(process.cwd(), filePath);
+    if (!fs_1.default.existsSync(resolvedPath)) {
+        const msg = `File not found: ${resolvedPath}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    const source = fs_1.default.readFileSync(resolvedPath, 'utf-8');
+    if (!source.includes('defineAgent')) {
+        const msg = 'File does not appear to be a Suzi agent (missing defineAgent).';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+            (0, ui_1.info)('Agent files must export `defineAgent({...})`.');
+        }
+        return;
+    }
+    if (!jsonMode) {
+        (0, ui_1.header)('Deploy Agent');
+        console.log();
+        (0, ui_1.label)('File', path_1.default.relative(process.cwd(), resolvedPath));
+        (0, ui_1.label)('Size', `${source.length} bytes`);
+        console.log();
+    }
+    // Determine title
+    let title = opts?.title;
+    if (!title && !opts?.update && !jsonMode && (0, tty_1.shouldUseInteractive)()) {
+        // Try to extract from source
+        const metaMatch = source.match(/name:\s*['"]([^'"]+)['"]/);
+        if (metaMatch) {
+            title = metaMatch[1];
+        }
+        else {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'title',
+                    message: 'Agent title:',
+                    default: path_1.default.basename(resolvedPath, path_1.default.extname(resolvedPath)),
+                },
+            ]);
+            title = answers.title;
+        }
+    }
+    const spinner = (0, tty_1.createSpinner)('Deploying agent...', jsonMode);
+    spinner?.start();
+    try {
+        let resp;
+        if (opts?.update) {
+            // Update existing agent
+            if (spinner)
+                spinner.text = 'Updating agent...';
+            resp = await (0, api_1.put)(`/api/agent/${opts.update}`, {
+                code: source,
+                ...(title ? { title } : {}),
+                ...(opts?.description ? { description: opts.description } : {}),
+            });
+        }
+        else {
+            // Create new agent
+            if (spinner)
+                spinner.text = 'Creating agent...';
+            resp = await (0, api_1.post)('/api/agent', {
+                code: source,
+                title: title || 'CLI Agent',
+                ...(opts?.description ? { description: opts.description } : {}),
+            });
+        }
+        if (!resp.ok) {
+            spinner?.fail();
+            const errorMsg = resp.data?.error || resp.data?.message || 'Unknown error';
+            const details = resp.data?.details;
+            if (jsonMode) {
+                (0, tty_1.outputJson)({ success: false, error: errorMsg, data: { details } });
+            }
+            else {
+                (0, ui_1.error)(`Deploy failed: ${errorMsg}`);
+                if (details) {
+                    console.log(ui_1.colors.muted(`  ${details}`));
+                }
+            }
+            (0, memory_1.appendLearning)({ category: 'error', message: `Deploy failed: ${errorMsg}`, command: 'agent deploy' });
+            return;
+        }
+        const agentData = resp.data;
+        // Activate if requested
+        if (opts?.activate) {
+            if (spinner)
+                spinner.text = 'Activating agent...';
+            const activateResp = await (0, api_1.post)(`/api/agent/${agentData.id}/activate`);
+            if (activateResp.ok) {
+                agentData.status = 'active';
+            }
+            else {
+                const activateError = activateResp.data?.error || activateResp.data?.message || 'Unknown error';
+                if (jsonMode) {
+                    (0, tty_1.outputJson)({ success: true, data: { agent: agentData, activationError: activateError } });
+                }
+                else {
+                    spinner?.warn(`Agent deployed but activation failed: ${activateError}`);
+                }
+                (0, memory_1.appendLearning)({ category: 'error', message: `Post-deploy activation failed: ${activateError}`, command: 'agent deploy --activate', agentId: agentData.id });
+                return;
+            }
+        }
+        spinner?.succeed(opts?.update ? 'Agent updated!' : 'Agent created!');
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: true, data: { agent: agentData } });
+            return;
+        }
+        console.log();
+        (0, ui_1.label)('Agent ID', agentData.id);
+        (0, ui_1.label)('Title', agentData.title || 'Untitled');
+        (0, ui_1.label)('Status', (0, ui_1.statusBadge)(agentData.status));
+        if (agentData.spec) {
+            const spec = (0, ui_1.safeParseJSON)(agentData.spec);
+            if (spec.triggers) {
+                (0, ui_1.label)('Triggers', Object.keys(spec.triggers).join(', '));
+            }
+        }
+        // Show action validation warnings
+        if (agentData.actionValidation?.issues?.length > 0) {
+            console.log();
+            (0, ui_1.warn)('Action validation issues:');
+            for (const issue of agentData.actionValidation.issues) {
+                if (issue.type === 'unknown_protocol') {
+                    console.log(`    ${ui_1.colors.warning('⚠')} Unknown protocol: ${chalk_1.default.bold(issue.protocol)} ${ui_1.colors.muted(`(line ${issue.line})`)}`);
+                }
+                else if (issue.type === 'unknown_action') {
+                    console.log(`    ${ui_1.colors.warning('⚠')} Unknown action: ${chalk_1.default.bold(issue.protocol + '.' + issue.action)} ${ui_1.colors.muted(`(line ${issue.line})`)}`);
+                }
+                if (issue.suggestions && issue.suggestions.length > 0) {
+                    console.log(`      ${ui_1.colors.muted('Did you mean:')} ${issue.suggestions.join(', ')}`);
+                }
+            }
+            console.log();
+            (0, ui_1.info)('Run `suzi agents validate` for detailed validation.');
+        }
+        console.log();
+        (0, ui_1.divider)();
+        if (agentData.status === 'draft') {
+            (0, ui_1.info)('Activate with: `suzi agents activate ' + agentData.id + '`');
+        }
+    }
+    catch (err) {
+        spinner?.fail();
+        const msg = `Deploy error: ${err.message}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        (0, memory_1.appendLearning)({ category: 'error', message: msg, command: 'agent deploy' });
+    }
+}
+async function validateAgentCommand(file, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    // Resolve file path
+    let filePath = file;
+    if (!filePath && !jsonMode && (0, tty_1.shouldUseInteractive)()) {
+        const cwd = process.cwd();
+        const scanDirs = [cwd, path_1.default.join(cwd, 'src')];
+        const agentFiles = [];
+        for (const dir of scanDirs) {
+            if (!fs_1.default.existsSync(dir))
+                continue;
+            for (const entry of fs_1.default.readdirSync(dir)) {
+                if (!entry.endsWith('.ts'))
+                    continue;
+                const full = path_1.default.join(dir, entry);
+                try {
+                    const content = fs_1.default.readFileSync(full, 'utf-8');
+                    if (content.includes('defineAgent')) {
+                        agentFiles.push(full);
+                    }
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+        if (agentFiles.length === 0) {
+            (0, ui_1.error)('No agent files found in current directory.');
+            (0, ui_1.info)('Create a .ts file with `defineAgent({...})` or specify a path.');
+            return;
+        }
+        if (agentFiles.length === 1) {
+            filePath = agentFiles[0];
+        }
+        else {
+            const { selected } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select an agent file to validate:',
+                    choices: agentFiles.map(f => ({
+                        name: path_1.default.relative(cwd, f),
+                        value: f,
+                    })),
+                },
+            ]);
+            filePath = selected;
+        }
+    }
+    if (!filePath) {
+        const msg = 'File path required in non-interactive mode.';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    const resolvedPath = path_1.default.resolve(process.cwd(), filePath);
+    if (!fs_1.default.existsSync(resolvedPath)) {
+        const msg = `File not found: ${resolvedPath}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    const source = fs_1.default.readFileSync(resolvedPath, 'utf-8');
+    if (!source.includes('defineAgent')) {
+        const msg = 'File does not appear to be a Suzi agent (missing defineAgent).';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+            (0, ui_1.info)('Agent files must export `defineAgent({...})`.');
+        }
+        return;
+    }
+    if (!jsonMode) {
+        (0, ui_1.header)('Validate Agent');
+        console.log();
+        (0, ui_1.label)('File', path_1.default.relative(process.cwd(), resolvedPath));
+        (0, ui_1.label)('Size', `${Buffer.byteLength(source, 'utf8')} bytes`);
+        console.log();
+    }
+    const spinner = (0, tty_1.createSpinner)('Validating agent...', jsonMode);
+    spinner?.start();
+    try {
+        const resp = await (0, api_1.post)('/api/agent/validate', { code: source });
+        if (!resp.ok) {
+            spinner?.fail();
+            const errorData = resp.data;
+            const msg = errorData?.message || 'Compilation error';
+            const details = errorData?.details;
+            if (jsonMode) {
+                (0, tty_1.outputJson)({ success: false, error: msg, data: { details } });
+            }
+            else {
+                (0, ui_1.error)(msg);
+                if (details) {
+                    console.log(ui_1.colors.muted(`  ${details}`));
+                }
+            }
+            return;
+        }
+        const data = resp.data;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: true, data });
+            return;
+        }
+        if (data.valid) {
+            spinner?.succeed('Agent is valid!');
+        }
+        else {
+            spinner?.fail('Validation issues found');
+            process.exitCode = 1;
+        }
+        console.log();
+        // Show spec summary
+        if (data.spec) {
+            if (data.spec.meta?.name) {
+                (0, ui_1.label)('Name', data.spec.meta.name);
+            }
+            (0, ui_1.label)('Triggers', Object.keys(data.spec.triggers || {}).join(', ') || 'none');
+            if (data.spec.resources) {
+                (0, ui_1.label)('Resources', Object.keys(data.spec.resources).join(', '));
+            }
+        }
+        // Show valid action references
+        const refs = data.actions?.references || [];
+        const issues = data.actions?.issues || [];
+        const issueKeys = new Set(issues.flatMap((i) => {
+            const keys = [`${i.protocol}.${i.action || ''}`];
+            if (i.type === 'unknown_protocol') {
+                keys.push(i.protocol);
+            }
+            return keys;
+        }));
+        if (refs.length > 0) {
+            console.log();
+            console.log(ui_1.colors.highlight('  Actions used:'));
+            for (const ref of refs) {
+                const key = `${ref.protocol}.${ref.action}`;
+                if (!issueKeys.has(key) && !issueKeys.has(ref.protocol)) {
+                    console.log(`    ${ui_1.colors.success('✓')} ${key} ${ui_1.colors.muted(`(line ${ref.line})`)}`);
+                }
+            }
+        }
+        // Show issues
+        if (issues.length > 0) {
+            console.log();
+            console.log(ui_1.colors.error('  Issues:'));
+            for (const issue of issues) {
+                if (issue.type === 'unknown_protocol') {
+                    console.log(`    ${ui_1.colors.error('✕')} Unknown protocol: ${ui_1.colors.highlight(issue.protocol)} ${ui_1.colors.muted(`(line ${issue.line})`)}`);
+                }
+                else if (issue.type === 'unknown_action') {
+                    console.log(`    ${ui_1.colors.error('✕')} Unknown action: ${ui_1.colors.highlight(issue.protocol + '.' + issue.action)} ${ui_1.colors.muted(`(line ${issue.line})`)}`);
+                }
+                if (issue.suggestions && issue.suggestions.length > 0) {
+                    console.log(`      ${ui_1.colors.muted('Did you mean:')} ${issue.suggestions.join(', ')}`);
+                }
+            }
+        }
+        console.log();
+        (0, ui_1.divider)();
+        if (data.valid) {
+            (0, ui_1.info)('Ready to deploy: `suzi agents deploy ' + path_1.default.relative(process.cwd(), resolvedPath) + '`');
+        }
+        else {
+            (0, ui_1.warn)('Fix the issues above before deploying.');
+        }
+    }
+    catch (err) {
+        spinner?.fail();
+        const msg = `Validation error: ${err.message}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+    }
+}
+async function activateAgentCommand(idOrName, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    const spinner = (0, tty_1.createSpinner)('Activating agent...', jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.post)(`/api/agent/${agent.id}/activate`);
+    if (!resp.ok) {
+        spinner?.fail();
+        const errorMsg = resp.data?.error || resp.data?.message || 'Unknown error';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: errorMsg });
+        }
+        else {
+            (0, ui_1.error)(`Failed to activate: ${errorMsg}`);
+        }
+        (0, memory_1.appendLearning)({ category: 'error', message: `Activate failed: ${errorMsg}`, command: 'agent activate', agentId: agent.id });
+        return;
+    }
+    spinner?.succeed();
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { agentId: agent.id, status: 'active' } });
+    }
+    else {
+        (0, ui_1.success)(`Agent ${agent.id.slice(0, 8)}... activated.`);
+    }
+}
+async function deactivateAgentCommand(idOrName, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    // Confirmation prompt for destructive action
+    if (!opts?.force && !jsonMode && (0, tty_1.shouldUseInteractive)()) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Deactivate "${agent.title || 'Untitled'}"? This will stop all triggers and scheduled executions.`,
+                default: false,
+            },
+        ]);
+        if (!answers.confirm) {
+            (0, ui_1.info)('Cancelled.');
+            return;
+        }
+    }
+    const spinner = (0, tty_1.createSpinner)('Deactivating agent...', jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.post)(`/api/agent/${agent.id}/deactivate`);
+    if (!resp.ok) {
+        spinner?.fail();
+        const errorMsg = resp.data?.error || resp.data?.message || 'Unknown error';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: errorMsg });
+        }
+        else {
+            (0, ui_1.error)(`Failed to deactivate: ${errorMsg}`);
+        }
+        (0, memory_1.appendLearning)({ category: 'error', message: `Deactivate failed: ${errorMsg}`, command: 'agent deactivate', agentId: agent.id });
+        return;
+    }
+    spinner?.succeed();
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { agentId: agent.id, status: 'inactive' } });
+    }
+    else {
+        (0, ui_1.success)(`Agent ${agent.id.slice(0, 8)}... deactivated.`);
+    }
+}
+async function executeAgentCommand(idOrName, trigger, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    // If no trigger specified, fetch agent to find manual triggers
+    let triggerName = trigger;
+    if (!triggerName) {
+        const agentResp = await (0, api_1.get)(`/api/agent/${agent.id}`);
+        if (agentResp.ok && agentResp.data?.spec) {
+            const spec = (0, ui_1.safeParseJSON)(agentResp.data.spec);
+            const triggers = Object.keys(spec.triggers || {});
+            if (triggers.length === 0) {
+                const msg = 'No triggers found on this agent.';
+                if (jsonMode) {
+                    (0, tty_1.outputJson)({ success: false, error: msg });
+                }
+                else {
+                    (0, ui_1.error)(msg);
+                }
+                return;
+            }
+            if (triggers.length === 1) {
+                triggerName = triggers[0];
+            }
+            else if (!jsonMode && (0, tty_1.shouldUseInteractive)()) {
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'trigger',
+                        message: 'Select a trigger to execute:',
+                        choices: triggers,
+                    },
+                ]);
+                triggerName = answers.trigger;
+            }
+            else {
+                const msg = 'Multiple triggers available. Specify trigger name.';
+                if (jsonMode) {
+                    (0, tty_1.outputJson)({ success: false, error: msg, data: { triggers } });
+                }
+                else {
+                    (0, ui_1.error)(msg);
+                    (0, ui_1.info)('Available triggers: ' + triggers.join(', '));
+                }
+                return;
+            }
+        }
+        else {
+            const msg = 'Could not fetch agent spec.';
+            if (jsonMode) {
+                (0, tty_1.outputJson)({ success: false, error: msg });
+            }
+            else {
+                (0, ui_1.error)(msg + ' Specify trigger name explicitly.');
+            }
+            return;
+        }
+    }
+    const spinner = (0, tty_1.createSpinner)(`Executing trigger "${triggerName}"...`, jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.post)(`/api/agent/${agent.id}/execute`, {
+        triggerName: triggerName,
+    });
+    if (!resp.ok) {
+        spinner?.fail();
+        const errorMsg = resp.data?.error || resp.data?.message || 'Unknown error';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: errorMsg });
+        }
+        else {
+            (0, ui_1.error)(`Execution failed: ${errorMsg}`);
+        }
+        (0, memory_1.appendLearning)({ category: 'error', message: `Execution failed: ${errorMsg}`, command: 'agent execute', agentId: agent.id });
+        return;
+    }
+    spinner?.succeed();
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { executionId: resp.data.executionId } });
+    }
+    else {
+        (0, ui_1.success)(`Execution started. Run ID: ${resp.data.executionId || 'N/A'}`);
+    }
+}
+async function logsAgentCommand(idOrName, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    const spinner = (0, tty_1.createSpinner)('Loading logs...', jsonMode);
+    spinner?.start();
+    let path = `/api/agent/${agent.id}/logs?limit=${opts?.limit || 20}`;
+    if (opts?.level)
+        path += `&level=${opts.level}`;
+    const resp = await (0, api_1.get)(path);
+    if (!resp.ok) {
+        spinner?.fail();
+        const msg = `Failed to load logs: ${resp.data?.error || 'Unknown error'}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    spinner?.stop();
+    const logs = resp.data.logs || [];
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { logs, count: logs.length } });
+        return;
+    }
+    if (logs.length === 0) {
+        (0, ui_1.info)('No logs found.');
+        return;
+    }
+    (0, ui_1.header)(`Agent Logs (${logs.length})`);
+    console.log();
+    for (const log of logs) {
+        const levelColor = log.level === 'error'
+            ? chalk_1.default.red
+            : log.level === 'warn'
+                ? chalk_1.default.yellow
+                : log.level === 'debug'
+                    ? chalk_1.default.gray
+                    : chalk_1.default.white;
+        const ts = new Date(log.createdAt).toLocaleTimeString();
+        console.log(`  ${ui_1.colors.muted(ts)} ${levelColor(`[${log.level}]`)} ${log.log}`);
+    }
+}
+async function codeAgentCommand(idOrName, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    const spinner = (0, tty_1.createSpinner)('Loading agent code...', jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.get)(`/api/agent/${agent.id}`);
+    if (!resp.ok) {
+        spinner?.fail();
+        const msg = `Agent not found: ${resp.data?.error || resp.data?.message || 'Unknown error'}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    spinner?.stop();
+    const agentData = resp.data;
+    if (!agentData.source) {
+        const msg = 'No source code found for this agent.';
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.info)(msg);
+        }
+        return;
+    }
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { source: agentData.source, title: agentData.title } });
+        return;
+    }
+    (0, ui_1.header)(agentData.title || 'Untitled Agent');
+    console.log();
+    const lines = agentData.source.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const lineNum = ui_1.colors.muted(String(i + 1).padStart(4));
+        console.log(`${lineNum}  ${lines[i]}`);
+    }
+    console.log();
+    console.log(ui_1.colors.muted(`  ${lines.length} lines`));
+}
+async function deleteAgentCommand(idOrName, opts) {
+    if (!(0, ui_1.requireAuth)())
+        return;
+    const jsonMode = opts?.json || false;
+    const agent = await (0, agent_picker_1.fetchAndPickAgent)(idOrName, jsonMode);
+    if (!agent)
+        return;
+    if (!opts?.force && !jsonMode && (0, tty_1.shouldUseInteractive)()) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Are you sure you want to delete agent ${agent.id.slice(0, 8)}...?`,
+                default: false,
+            },
+        ]);
+        if (!answers.confirm) {
+            (0, ui_1.info)('Cancelled.');
+            return;
+        }
+    }
+    const spinner = (0, tty_1.createSpinner)('Deleting agent...', jsonMode);
+    spinner?.start();
+    const resp = await (0, api_1.del)(`/api/agent/${agent.id}`);
+    if (!resp.ok) {
+        spinner?.fail();
+        const msg = `Failed to delete: ${resp.data?.error || 'Unknown error'}`;
+        if (jsonMode) {
+            (0, tty_1.outputJson)({ success: false, error: msg });
+        }
+        else {
+            (0, ui_1.error)(msg);
+        }
+        return;
+    }
+    spinner?.succeed();
+    if (jsonMode) {
+        (0, tty_1.outputJson)({ success: true, data: { agentId: agent.id, deleted: true } });
+    }
+    else {
+        (0, ui_1.success)(`Agent ${agent.id.slice(0, 8)}... deleted.`);
+    }
+}
+//# sourceMappingURL=agent.js.map