opc-agent 0.2.0 → 0.4.0

package/dist/analytics/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Agent Analytics — track messages, response times, skill usage, errors, tokens.
+ */
+export interface AnalyticsSnapshot {
+    messagesProcessed: number;
+    avgResponseTimeMs: number;
+    skillUsage: Record<string, number>;
+    errorCount: number;
+    tokenUsage: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    uptime: number;
+    startedAt: number;
+}
+export declare class Analytics {
+    private messagesProcessed;
+    private totalResponseTimeMs;
+    private skillUsage;
+    private errorCount;
+    private tokenUsage;
+    private startedAt;
+    recordMessage(responseTimeMs: number): void;
+    recordSkillUsage(skillName: string): void;
+    recordError(): void;
+    recordTokens(input: number, output: number): void;
+    getSnapshot(): AnalyticsSnapshot;
+    reset(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/analytics/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Analytics = void 0;
+class Analytics {
+    messagesProcessed = 0;
+    totalResponseTimeMs = 0;
+    skillUsage = {};
+    errorCount = 0;
+    tokenUsage = { input: 0, output: 0 };
+    startedAt = Date.now();
+    recordMessage(responseTimeMs) {
+        this.messagesProcessed++;
+        this.totalResponseTimeMs += responseTimeMs;
+    }
+    recordSkillUsage(skillName) {
+        this.skillUsage[skillName] = (this.skillUsage[skillName] ?? 0) + 1;
+    }
+    recordError() {
+        this.errorCount++;
+    }
+    recordTokens(input, output) {
+        this.tokenUsage.input += input;
+        this.tokenUsage.output += output;
+    }
+    getSnapshot() {
+        return {
+            messagesProcessed: this.messagesProcessed,
+            avgResponseTimeMs: this.messagesProcessed > 0
+                ? Math.round(this.totalResponseTimeMs / this.messagesProcessed)
+                : 0,
+            skillUsage: { ...this.skillUsage },
+            errorCount: this.errorCount,
+            tokenUsage: {
+                input: this.tokenUsage.input,
+                output: this.tokenUsage.output,
+                total: this.tokenUsage.input + this.tokenUsage.output,
+            },
+            uptime: Date.now() - this.startedAt,
+            startedAt: this.startedAt,
+        };
+    }
+    reset() {
+        this.messagesProcessed = 0;
+        this.totalResponseTimeMs = 0;
+        this.skillUsage = {};
+        this.errorCount = 0;
+        this.tokenUsage = { input: 0, output: 0 };
+        this.startedAt = Date.now();
+    }
+}
+exports.Analytics = Analytics;
+//# sourceMappingURL=index.js.map

package/dist/channels/voice.d.ts

@@ -0,0 +1,43 @@
+import { BaseChannel } from './index';
+export interface STTProvider {
+    name: string;
+    transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
+}
+export interface TTSProvider {
+    name: string;
+    synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+export interface STTOptions {
+    language?: string;
+    model?: string;
+}
+export interface TTSOptions {
+    voice?: string;
+    speed?: number;
+    language?: string;
+}
+export interface VoiceChannelConfig {
+    sttProvider?: STTProvider;
+    ttsProvider?: TTSProvider;
+    sampleRate?: number;
+    language?: string;
+}
+export declare class VoiceChannel extends BaseChannel {
+    type: string;
+    private config;
+    private logger;
+    private running;
+    constructor(config?: VoiceChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    /** Process audio input: STT → Agent → TTS */
+    processAudio(audio: Buffer): Promise<{
+        text: string;
+        response: string;
+        audioResponse?: Buffer;
+    }>;
+    setSTTProvider(provider: STTProvider): void;
+    setTTSProvider(provider: TTSProvider): void;
+}
+//# sourceMappingURL=voice.d.ts.map

package/dist/channels/voice.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceChannel = void 0;
+const index_1 = require("./index");
+const logger_1 = require("../core/logger");
+// ── Voice Channel ───────────────────────────────────────────
+class VoiceChannel extends index_1.BaseChannel {
+    type = 'voice';
+    config;
+    logger = new logger_1.Logger('voice-channel');
+    running = false;
+    constructor(config) {
+        super();
+        this.config = config ?? {};
+    }
+    async start() {
+        this.running = true;
+        this.logger.info('Voice channel started', {
+            stt: this.config.sttProvider?.name ?? 'none',
+            tts: this.config.ttsProvider?.name ?? 'none',
+        });
+    }
+    async stop() {
+        this.running = false;
+        this.logger.info('Voice channel stopped');
+    }
+    isRunning() {
+        return this.running;
+    }
+    /** Process audio input: STT → Agent → TTS */
+    async processAudio(audio) {
+        if (!this.handler)
+            throw new Error('No message handler set');
+        // STT
+        let text;
+        if (this.config.sttProvider) {
+            text = await this.config.sttProvider.transcribe(audio, { language: this.config.language });
+        }
+        else {
+            text = audio.toString('utf-8'); // Fallback: treat as text
+        }
+        this.logger.debug('STT result', { text });
+        // Create message and send to agent
+        const message = {
+            id: `voice_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            role: 'user',
+            content: text,
+            timestamp: Date.now(),
+            metadata: { channel: 'voice' },
+        };
+        const response = await this.handler(message);
+        // TTS
+        let audioResponse;
+        if (this.config.ttsProvider) {
+            audioResponse = await this.config.ttsProvider.synthesize(response.content, { language: this.config.language });
+        }
+        return { text, response: response.content, audioResponse };
+    }
+    setSTTProvider(provider) {
+        this.config.sttProvider = provider;
+    }
+    setTTSProvider(provider) {
+        this.config.ttsProvider = provider;
+    }
+}
+exports.VoiceChannel = VoiceChannel;
+//# sourceMappingURL=voice.js.map

package/dist/channels/webhook.d.ts

@@ -0,0 +1,40 @@
+import { BaseChannel } from './index';
+export interface WebhookConfig {
+    port?: number;
+    path?: string;
+    secret?: string;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+    outgoing?: WebhookOutgoing[];
+}
+export interface WebhookOutgoing {
+    name: string;
+    url: string;
+    secret?: string;
+    events: string[];
+}
+export interface WebhookPayload {
+    event: string;
+    data: unknown;
+    timestamp: number;
+    id: string;
+}
+export declare class WebhookChannel extends BaseChannel {
+    type: string;
+    private config;
+    private server;
+    private logger;
+    private outgoing;
+    constructor(config?: WebhookConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Send a webhook to outgoing endpoints */
+    send(event: string, data: unknown): Promise<void>;
+    private sendWithRetry;
+    private httpPost;
+    private readBody;
+    verifySignature(body: string, signature: string, secret: string): boolean;
+    createSignature(body: string, secret: string): string;
+    addOutgoing(outgoing: WebhookOutgoing): void;
+}
+//# sourceMappingURL=webhook.d.ts.map

package/dist/channels/webhook.js

@@ -0,0 +1,193 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookChannel = void 0;
+const index_1 = require("./index");
+const logger_1 = require("../core/logger");
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+// ── Webhook Channel ─────────────────────────────────────────
+class WebhookChannel extends index_1.BaseChannel {
+    type = 'webhook';
+    config;
+    server = null;
+    logger = new logger_1.Logger('webhook-channel');
+    outgoing = [];
+    constructor(config) {
+        super();
+        this.config = config ?? {};
+        this.outgoing = config?.outgoing ?? [];
+    }
+    async start() {
+        const port = this.config.port ?? 3100;
+        const path = this.config.path ?? '/webhook';
+        this.server = http.createServer(async (req, res) => {
+            if (req.url !== path || req.method !== 'POST') {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            try {
+                const body = await this.readBody(req);
+                // Verify signature if secret configured
+                if (this.config.secret) {
+                    const signature = req.headers['x-webhook-signature'];
+                    if (!this.verifySignature(body, signature, this.config.secret)) {
+                        res.writeHead(401);
+                        res.end('Invalid signature');
+                        return;
+                    }
+                }
+                const payload = JSON.parse(body);
+                const message = {
+                    id: payload.id ?? `wh_${Date.now()}`,
+                    role: 'user',
+                    content: typeof payload.data === 'string' ? payload.data : JSON.stringify(payload.data),
+                    timestamp: payload.timestamp ?? Date.now(),
+                    metadata: { channel: 'webhook', event: payload.event },
+                };
+                if (this.handler) {
+                    const response = await this.handler(message);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'ok', response: response.content }));
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'ok' }));
+                }
+            }
+            catch (err) {
+                this.logger.error('Webhook error', { error: err.message });
+                res.writeHead(500);
+                res.end('Internal error');
+            }
+        });
+        return new Promise((resolve) => {
+            this.server.listen(port, () => {
+                this.logger.info('Webhook channel started', { port, path });
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.logger.info('Webhook channel stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /** Send a webhook to outgoing endpoints */
+    async send(event, data) {
+        const targets = this.outgoing.filter(o => o.events.includes(event) || o.events.includes('*'));
+        for (const target of targets) {
+            const payload = {
+                event,
+                data,
+                timestamp: Date.now(),
+                id: `wh_out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            };
+            await this.sendWithRetry(target, payload);
+        }
+    }
+    async sendWithRetry(target, payload) {
+        const maxRetries = this.config.retryAttempts ?? 3;
+        const retryDelay = this.config.retryDelayMs ?? 1000;
+        const body = JSON.stringify(payload);
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                await this.httpPost(target.url, body, target.secret);
+                return;
+            }
+            catch (err) {
+                if (attempt === maxRetries) {
+                    this.logger.error('Webhook delivery failed', { target: target.name, error: err.message });
+                    throw err;
+                }
+                await new Promise(r => setTimeout(r, retryDelay * Math.pow(2, attempt)));
+            }
+        }
+    }
+    httpPost(url, body, secret) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const headers = { 'Content-Type': 'application/json' };
+            if (secret) {
+                headers['x-webhook-signature'] = this.createSignature(body, secret);
+            }
+            const req = http.request({ hostname: urlObj.hostname, port: urlObj.port, path: urlObj.pathname, method: 'POST', headers }, (res) => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                }
+                res.resume();
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (c) => chunks.push(c));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+            req.on('error', reject);
+        });
+    }
+    verifySignature(body, signature, secret) {
+        if (!signature)
+            return false;
+        const expected = this.createSignature(body, secret);
+        if (signature.length !== expected.length)
+            return false;
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+    }
+    createSignature(body, secret) {
+        return crypto.createHmac('sha256', secret).update(body).digest('hex');
+    }
+    addOutgoing(outgoing) {
+        this.outgoing.push(outgoing);
+    }
+}
+exports.WebhookChannel = WebhookChannel;
+//# sourceMappingURL=webhook.js.map

package/dist/cli.js

@@ -44,9 +44,17 @@ const customer_service_1 = require("./templates/customer-service");
 const sales_assistant_1 = require("./templates/sales-assistant");
 const knowledge_base_1 = require("./templates/knowledge-base");
 const code_reviewer_1 = require("./templates/code-reviewer");
+const hr_recruiter_1 = require("./templates/hr-recruiter");
+const project_manager_1 = require("./templates/project-manager");
+const content_writer_1 = require("./templates/content-writer");
+const legal_assistant_1 = require("./templates/legal-assistant");
+const financial_advisor_1 = require("./templates/financial-advisor");
+const executive_assistant_1 = require("./templates/executive-assistant");
 const customer_service_2 = require("./templates/customer-service");
+const analytics_1 = require("./analytics");
+const workflow_1 = require("./core/workflow");
+const versioning_1 = require("./core/versioning");
 const program = new commander_1.Command();
-// ── Colorful output helpers ──────────────────────────────────
 const color = {
     green: (s) => `\x1b[32m${s}\x1b[0m`,
     red: (s) => `\x1b[31m${s}\x1b[0m`,
@@ -68,10 +76,16 @@ const icon = {
     file: '📄',
 };
 const TEMPLATES = {
-    'customer-service': { label: 'Customer Service — FAQ + human handoff', factory: customer_service_1.createCustomerServiceConfig },
-    'sales-assistant': { label: 'Sales Assistant — product Q&A + lead capture', factory: sales_assistant_1.createSalesAssistantConfig },
-    'knowledge-base': { label: 'Knowledge Base — RAG with DeepBrain', factory: knowledge_base_1.createKnowledgeBaseConfig },
-    'code-reviewer': { label: 'Code Reviewer — bug detection + style checks', factory: code_reviewer_1.createCodeReviewerConfig },
+    'customer-service': { label: 'Customer Service - FAQ + human handoff', factory: customer_service_1.createCustomerServiceConfig },
+    'sales-assistant': { label: 'Sales Assistant - product Q&A + lead capture', factory: sales_assistant_1.createSalesAssistantConfig },
+    'knowledge-base': { label: 'Knowledge Base - RAG with DeepBrain', factory: knowledge_base_1.createKnowledgeBaseConfig },
+    'code-reviewer': { label: 'Code Reviewer - bug detection + style checks', factory: code_reviewer_1.createCodeReviewerConfig },
+    'hr-recruiter': { label: 'HR Recruiter - resume screening + interview scheduling', factory: hr_recruiter_1.createHRRecruiterConfig },
+    'project-manager': { label: 'Project Manager - task tracking + meeting notes', factory: project_manager_1.createProjectManagerConfig },
+    'content-writer': { label: 'Content Writer - blog posts + social media + SEO', factory: content_writer_1.createContentWriterConfig },
+    'legal-assistant': { label: 'Legal Assistant - contract review + compliance + legal research', factory: legal_assistant_1.createLegalAssistantConfig },
+    'financial-advisor': { label: 'Financial Advisor - budget analysis + expense tracking + planning', factory: financial_advisor_1.createFinancialAdvisorConfig },
+    'executive-assistant': { label: 'Executive Assistant - calendar + email drafting + meeting prep', factory: executive_assistant_1.createExecutiveAssistantConfig },
 };
 async function prompt(question, defaultValue) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -94,8 +108,8 @@ async function select(question, options) {
 }
 program
     .name('opc')
-    .description('OPC Agent — Open Agent Framework for business workstations')
-    .version('0.2.0');
+    .description('OPC Agent - Open Agent Framework for business workstations')
+    .version('0.4.0');
 program
     .command('init')
     .description('Initialize a new OPC agent project (interactive)')
@@ -103,7 +117,7 @@ program
     .option('-t, --template <template>', 'Template to use')
     .option('-y, --yes', 'Skip prompts, use defaults')
     .action(async (nameArg, opts) => {
-    console.log(`\n${icon.rocket} ${color.bold('OPC Agent — Create New Project')}\n`);
+    console.log(`\n${icon.rocket} ${color.bold('OPC Agent - Create New Project')}\n`);
     const name = opts.yes ? (nameArg ?? 'my-agent') : (nameArg ?? await prompt('Project name', 'my-agent'));
     const template = opts.yes
         ? (opts.template ?? 'customer-service')
@@ -120,7 +134,7 @@ program
     fs.writeFileSync(path.join(dir, 'oad.yaml'), yaml.dump(config, { lineWidth: 120 }));
     fs.writeFileSync(path.join(dir, 'README.md'), `# ${name}\n\nCreated with OPC Agent using the \`${template}\` template.\n\n## Run\n\n\`\`\`bash\nopc run\n\`\`\`\n`);
     console.log(`\n${icon.success} Created agent project: ${color.bold(name + '/')}`);
-    console.log(`   ${icon.file} oad.yaml — Agent definition`);
+    console.log(`   ${icon.file} oad.yaml - Agent definition`);
     console.log(`   ${icon.file} README.md`);
     console.log(`\n   Template: ${color.cyan(template)}`);
     console.log(`\n${color.dim('Next:')} cd ${name} && opc run\n`);
@@ -159,6 +173,11 @@ program
         console.log(`  Channels:    ${s.channels.map(c => c.type).join(', ') || color.dim('(none)')}`);
         console.log(`  Skills:      ${s.skills.map(sk => sk.name).join(', ') || color.dim('(none)')}`);
         console.log(`  Trust:       ${s.dtv?.trust?.level ?? 'sandbox'}`);
+        console.log(`  Streaming:   ${s.streaming ? 'enabled' : 'disabled'}`);
+        console.log(`  Locale:      ${s.locale ?? 'en'}`);
+        if (s.room) {
+            console.log(`  Room:        ${s.room.name}`);
+        }
         if (m.marketplace) {
             console.log(`  Category:    ${m.marketplace.category ?? color.dim('(none)')}`);
             console.log(`  Pricing:     ${m.marketplace.pricing ?? 'free'}`);
@@ -227,7 +246,7 @@ program
     .description('Hot-reload development mode')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
     .action(async (opts) => {
-    console.log(`\n${icon.gear} ${color.bold('Development mode')} — watching for changes...\n`);
+    console.log(`\n${icon.gear} ${color.bold('Development mode')} - watching for changes...\n`);
     let runtime = null;
     const startAgent = async () => {
         try {
@@ -247,13 +266,12 @@ program
         }
     };
     await startAgent();
-    // Watch for file changes
     const watchPaths = [opts.file, 'src'];
     for (const watchPath of watchPaths) {
         if (fs.existsSync(watchPath)) {
             const isDir = fs.statSync(watchPath).isDirectory();
-            fs.watch(watchPath, { recursive: isDir }, async (event, filename) => {
-                console.log(`\n${icon.info} ${color.dim(`Change detected: ${filename}`)} — restarting...`);
+            fs.watch(watchPath, { recursive: isDir }, async (_event, filename) => {
+                console.log(`\n${icon.info} ${color.dim(`Change detected: ${filename}`)} - restarting...`);
                 await startAgent();
             });
         }
@@ -314,5 +332,131 @@ program
     console.log(`   Browse templates with: ${color.cyan('opc init --template <name>')}`);
     console.log(`\n   Available templates: ${Object.keys(TEMPLATES).map(t => color.cyan(t)).join(', ')}\n`);
 });
+// ── Tool commands ────────────────────────────────────────────
+const toolCmd = program.command('tool').description('Manage MCP tools');
+toolCmd
+    .command('list')
+    .description('List available MCP tools')
+    .action(() => {
+    console.log(`\n${icon.gear} ${color.bold('MCP Tools')}\n`);
+    console.log(`  ${color.dim('No tools installed yet.')}`);
+    console.log(`\n  Add tools with: ${color.cyan('opc tool add <name>')}\n`);
+});
+toolCmd
+    .command('add')
+    .description('Add an MCP tool from registry')
+    .argument('<name>', 'Tool name')
+    .action((name) => {
+    console.log(`\n🚧 Tool registry coming soon!`);
+    console.log(`   Would add tool: ${color.cyan(name)}\n`);
+});
+// ── Plugin commands ──────────────────────────────────────────
+const pluginCmd = program.command('plugin').description('Manage plugins');
+pluginCmd
+    .command('list')
+    .description('List installed plugins')
+    .action(() => {
+    console.log(`\n${icon.gear} ${color.bold('Installed Plugins')}\n`);
+    console.log(`  ${color.dim('No plugins installed yet.')}`);
+    console.log(`\n  Add plugins with: ${color.cyan('opc plugin add <name>')}\n`);
+});
+pluginCmd
+    .command('add')
+    .description('Add a plugin')
+    .argument('<name>', 'Plugin name')
+    .action((name) => {
+    console.log(`\n🚧 Plugin registry coming soon!`);
+    console.log(`   Would add plugin: ${color.cyan(name)}\n`);
+});
+// ── Stats command ────────────────────────────────────────────
+program
+    .command('stats')
+    .description('Show agent analytics')
+    .action(() => {
+    const analytics = new analytics_1.Analytics();
+    // Show demo stats
+    const snap = analytics.getSnapshot();
+    console.log(`\n${icon.gear} ${color.bold('Agent Analytics')}\n`);
+    console.log(`  Messages Processed: ${snap.messagesProcessed}`);
+    console.log(`  Avg Response Time:  ${snap.avgResponseTimeMs}ms`);
+    console.log(`  Error Count:        ${snap.errorCount}`);
+    console.log(`  Token Usage:        ${snap.tokenUsage.total} (in: ${snap.tokenUsage.input}, out: ${snap.tokenUsage.output})`);
+    console.log(`  Uptime:             ${Math.round(snap.uptime / 1000)}s`);
+    console.log(`\n  ${color.dim('Run an agent to collect analytics data.')}\n`);
+});
+// 🔄 Workflow commands ────────────────────────────────────────
+const workflowCmd = program.command('workflow').description('Manage workflows');
+workflowCmd
+    .command('run')
+    .description('Run a workflow defined in OAD')
+    .argument('<name>', 'Workflow name')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (name, opts) => {
+    console.log(`\n${icon.gear} Running workflow "${color.bold(name)}"...`);
+    const runtime = new runtime_1.AgentRuntime();
+    const config = await runtime.loadConfig(opts.file);
+    const workflows = config.spec.workflows ?? [];
+    const wfDef = workflows.find((w) => w.name === name);
+    if (!wfDef) {
+        console.error(`${icon.error} Workflow "${name}" not found in OAD.`);
+        process.exit(1);
+    }
+    const engine = new workflow_1.WorkflowEngine();
+    engine.registerWorkflow(wfDef);
+    console.log(`${icon.success} Workflow "${name}" loaded with ${wfDef.steps?.length ?? 0} steps.`);
+    console.log(`${color.dim('   Workflow execution requires a running agent context.')}\n`);
+});
+workflowCmd
+    .command('list')
+    .description('List workflows in OAD')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    const runtime = new runtime_1.AgentRuntime();
+    const config = await runtime.loadConfig(opts.file);
+    const workflows = config.spec.workflows ?? [];
+    console.log(`\n${icon.gear} ${color.bold('Workflows')}\n`);
+    if (workflows.length === 0) {
+        console.log(`  ${color.dim('No workflows defined.')}\n`);
+    }
+    else {
+        for (const wf of workflows) {
+            console.log(`  ${color.cyan(wf.name)} - ${wf.description ?? color.dim('(no description)')}`);
+        }
+        console.log();
+    }
+});
+// 📦 Version commands ─────────────────────────────────────────
+const versionCmd = program.command('version').description('Manage agent versions');
+versionCmd
+    .command('list')
+    .description('List saved versions')
+    .action(() => {
+    const vm = new versioning_1.VersionManager();
+    const versions = vm.list();
+    console.log(`\n${icon.gear} ${color.bold('Agent Versions')}\n`);
+    if (versions.length === 0) {
+        console.log(`  ${color.dim('No versions saved.')}\n`);
+    }
+    else {
+        for (const v of versions) {
+            console.log(`  ${color.cyan(v.version)} - ${new Date(v.timestamp).toISOString()} ${v.description ?? ''}`);
+        }
+        console.log();
+    }
+});
+versionCmd
+    .command('rollback')
+    .description('Rollback to a saved version')
+    .argument('<version>', 'Version to rollback to')
+    .action((version) => {
+    const vm = new versioning_1.VersionManager();
+    const oad = vm.rollback(version);
+    if (!oad) {
+        console.error(`${icon.error} Version "${version}" not found.`);
+        process.exit(1);
+    }
+    fs.writeFileSync('oad.yaml', oad);
+    console.log(`${icon.success} Rolled back to version ${color.bold(version)}.`);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map