opc-agent 0.1.0 → 0.3.0

package/dist/channels/telegram.d.ts

@@ -0,0 +1,21 @@
+import { BaseChannel } from './index';
+/**
+ * Telegram channel — basic webhook handler for Telegram Bot API.
+ * Set TELEGRAM_BOT_TOKEN env var or pass in config.
+ */
+export declare class TelegramChannel extends BaseChannel {
+    readonly type = "telegram";
+    private token;
+    private webhookUrl?;
+    private server;
+    private port;
+    constructor(options?: {
+        token?: string;
+        webhookUrl?: string;
+        port?: number;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private sendMessage;
+}
+//# sourceMappingURL=telegram.d.ts.map

package/dist/channels/telegram.js

@@ -0,0 +1,120 @@
+"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.TelegramChannel = void 0;
+const index_1 = require("./index");
+/**
+ * Telegram channel — basic webhook handler for Telegram Bot API.
+ * Set TELEGRAM_BOT_TOKEN env var or pass in config.
+ */
+class TelegramChannel extends index_1.BaseChannel {
+    type = 'telegram';
+    token;
+    webhookUrl;
+    server = null;
+    port;
+    constructor(options = {}) {
+        super();
+        this.token = options.token ?? process.env.TELEGRAM_BOT_TOKEN ?? '';
+        this.webhookUrl = options.webhookUrl;
+        this.port = options.port ?? 3001;
+    }
+    async start() {
+        if (!this.token) {
+            console.warn('[TelegramChannel] No bot token provided. Set TELEGRAM_BOT_TOKEN or pass token in config.');
+            return;
+        }
+        const express = (await Promise.resolve().then(() => __importStar(require('express')))).default;
+        const app = express();
+        app.use(express.json());
+        app.post(`/webhook/${this.token}`, async (req, res) => {
+            try {
+                const update = req.body;
+                if (update.message?.text && this.handler) {
+                    const msg = {
+                        id: `tg_${update.message.message_id}`,
+                        role: 'user',
+                        content: update.message.text,
+                        timestamp: update.message.date * 1000,
+                        metadata: {
+                            sessionId: `tg_${update.message.chat.id}`,
+                            chatId: update.message.chat.id,
+                            userId: update.message.from?.id,
+                            platform: 'telegram',
+                        },
+                    };
+                    const response = await this.handler(msg);
+                    await this.sendMessage(update.message.chat.id, response.content);
+                }
+                res.json({ ok: true });
+            }
+            catch (err) {
+                console.error('[TelegramChannel] Error handling update:', err);
+                res.status(500).json({ error: 'Internal error' });
+            }
+        });
+        app.get('/health', (_req, res) => {
+            res.json({ status: 'ok', channel: 'telegram' });
+        });
+        return new Promise((resolve) => {
+            this.server = app.listen(this.port, () => {
+                console.log(`[TelegramChannel] Webhook server on port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (!this.server)
+                return resolve();
+            this.server.close((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async sendMessage(chatId, text) {
+        const url = `https://api.telegram.org/bot${this.token}/sendMessage`;
+        try {
+            await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ chat_id: chatId, text, parse_mode: 'Markdown' }),
+            });
+        }
+        catch (err) {
+            console.error('[TelegramChannel] Failed to send message:', err);
+        }
+    }
+}
+exports.TelegramChannel = TelegramChannel;
+//# sourceMappingURL=telegram.js.map

package/dist/channels/websocket.d.ts

@@ -0,0 +1,15 @@
+import { BaseChannel } from './index';
+/**
+ * WebSocket channel — real-time bidirectional communication.
+ */
+export declare class WebSocketChannel extends BaseChannel {
+    readonly type = "websocket";
+    private wss;
+    private port;
+    private clients;
+    constructor(port?: number);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    broadcast(content: string): void;
+}
+//# sourceMappingURL=websocket.d.ts.map

package/dist/channels/websocket.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketChannel = void 0;
+const index_1 = require("./index");
+const ws_1 = require("ws");
+/**
+ * WebSocket channel — real-time bidirectional communication.
+ */
+class WebSocketChannel extends index_1.BaseChannel {
+    type = 'websocket';
+    wss = null;
+    port;
+    clients = new Set();
+    constructor(port = 3002) {
+        super();
+        this.port = port;
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.wss = new ws_1.WebSocketServer({ port: this.port });
+            this.wss.on('connection', (ws) => {
+                this.clients.add(ws);
+                ws.on('message', async (data) => {
+                    if (!this.handler)
+                        return;
+                    try {
+                        const parsed = JSON.parse(data.toString());
+                        const msg = {
+                            id: parsed.id ?? `ws_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                            role: 'user',
+                            content: parsed.content ?? parsed.message ?? data.toString(),
+                            timestamp: Date.now(),
+                            metadata: {
+                                sessionId: parsed.sessionId ?? 'ws-default',
+                                platform: 'websocket',
+                            },
+                        };
+                        const response = await this.handler(msg);
+                        ws.send(JSON.stringify({
+                            id: response.id,
+                            content: response.content,
+                            timestamp: response.timestamp,
+                        }));
+                    }
+                    catch (err) {
+                        ws.send(JSON.stringify({ error: 'Invalid message format' }));
+                    }
+                });
+                ws.on('close', () => {
+                    this.clients.delete(ws);
+                });
+                ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+            });
+            this.wss.on('listening', () => {
+                console.log(`[WebSocketChannel] Listening on port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        for (const client of this.clients) {
+            client.close();
+        }
+        this.clients.clear();
+        return new Promise((resolve, reject) => {
+            if (!this.wss)
+                return resolve();
+            this.wss.close((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    broadcast(content) {
+        const msg = JSON.stringify({ type: 'broadcast', content, timestamp: Date.now() });
+        for (const client of this.clients) {
+            if (client.readyState === 1) { // OPEN
+                client.send(msg);
+            }
+        }
+    }
+}
+exports.WebSocketChannel = WebSocketChannel;
+//# sourceMappingURL=websocket.js.map

package/dist/cli.js

@@ -38,46 +38,148 @@ const commander_1 = require("commander");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
+const readline = __importStar(require("readline"));
 const runtime_1 = require("./core/runtime");
 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 customer_service_2 = require("./templates/customer-service");
+const analytics_1 = require("./analytics");
 const program = new commander_1.Command();
+const color = {
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    blue: (s) => `\x1b[34m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+const icon = {
+    success: color.green('✔'),
+    error: color.red('✘'),
+    warn: color.yellow('⚠'),
+    info: color.blue('ℹ'),
+    rocket: '🚀',
+    package: '📦',
+    search: '🔍',
+    gear: '⚙️',
+    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 },
+    '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 },
+};
+async function prompt(question, defaultValue) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = defaultValue ? ` ${color.dim(`(${defaultValue})`)}` : '';
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+async function select(question, options) {
+    console.log(`\n${question}`);
+    options.forEach((opt, i) => {
+        console.log(`  ${color.cyan(`${i + 1})`)} ${opt.label}`);
+    });
+    const answer = await prompt(`\nChoose ${color.dim('(1-' + options.length + ')')}`, '1');
+    const idx = parseInt(answer) - 1;
+    return options[Math.max(0, Math.min(idx, options.length - 1))].value;
+}
 program
     .name('opc')
     .description('OPC Agent — Open Agent Framework for business workstations')
-    .version('0.1.0');
+    .version('0.3.0');
 program
     .command('init')
-    .description('Initialize a new OPC agent project')
-    .argument('[name]', 'Project name', 'my-agent')
-    .option('-t, --template <template>', 'Template to use', 'customer-service')
-    .action(async (name, opts) => {
+    .description('Initialize a new OPC agent project (interactive)')
+    .argument('[name]', 'Project name')
+    .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`);
+    const name = opts.yes ? (nameArg ?? 'my-agent') : (nameArg ?? await prompt('Project name', 'my-agent'));
+    const template = opts.yes
+        ? (opts.template ?? 'customer-service')
+        : (opts.template ?? await select('Select a template:', Object.entries(TEMPLATES).map(([value, { label }]) => ({ value, label }))));
     const dir = path.resolve(name);
     if (fs.existsSync(dir)) {
-        console.error(`Directory ${name} already exists.`);
+        console.error(`\n${icon.error} Directory ${color.bold(name)} already exists.`);
         process.exit(1);
     }
     fs.mkdirSync(dir, { recursive: true });
-    const config = (0, customer_service_1.createCustomerServiceConfig)();
+    const factory = TEMPLATES[template]?.factory ?? customer_service_1.createCustomerServiceConfig;
+    const config = factory();
     config.metadata.name = name;
     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.\n\n## Run\n\n\`\`\`bash\nopc run\n\`\`\`\n`);
-    console.log(`✅ Created agent project: ${name}/`);
-    console.log(`   📄 oad.yaml — Agent definition`);
-    console.log(`   📖 README.md`);
-    console.log(`\nNext: cd ${name} && opc run`);
+    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} README.md`);
+    console.log(`\n   Template: ${color.cyan(template)}`);
+    console.log(`\n${color.dim('Next:')} cd ${name} && opc run\n`);
 });
 program
     .command('create')
     .description('Create an agent from a template')
     .argument('<name>', 'Agent name')
     .option('-t, --template <template>', 'Template', 'customer-service')
-    .action(async (name) => {
-    const config = (0, customer_service_1.createCustomerServiceConfig)();
+    .action(async (name, opts) => {
+    const factory = TEMPLATES[opts.template]?.factory ?? customer_service_1.createCustomerServiceConfig;
+    const config = factory();
     config.metadata.name = name;
     const outFile = `${name}-oad.yaml`;
     fs.writeFileSync(outFile, yaml.dump(config, { lineWidth: 120 }));
-    console.log(`✅ Created ${outFile}`);
+    console.log(`${icon.success} Created ${color.bold(outFile)}`);
+});
+program
+    .command('info')
+    .description('Show agent info from OAD')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    try {
+        const runtime = new runtime_1.AgentRuntime();
+        const config = await runtime.loadConfig(opts.file);
+        const m = config.metadata;
+        const s = config.spec;
+        console.log(`\n${icon.gear} ${color.bold('Agent Info')}\n`);
+        console.log(`  Name:        ${color.cyan(m.name)}`);
+        console.log(`  Version:     ${m.version}`);
+        console.log(`  Description: ${m.description ?? color.dim('(none)')}`);
+        console.log(`  Author:      ${m.author ?? color.dim('(none)')}`);
+        console.log(`  License:     ${m.license}`);
+        console.log(`  Model:       ${s.model}`);
+        console.log(`  Provider:    ${s.provider?.default ?? 'deepseek'}`);
+        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'}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`${icon.error} Failed to read OAD:`, err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
 });
 program
     .command('build')
@@ -87,10 +189,10 @@ program
     try {
         const runtime = new runtime_1.AgentRuntime();
         const config = await runtime.loadConfig(opts.file);
-        console.log(`✅ Valid OAD: ${config.metadata.name} v${config.metadata.version}`);
+        console.log(`${icon.success} Valid OAD: ${color.bold(config.metadata.name)} v${config.metadata.version}`);
     }
     catch (err) {
-        console.error('❌ Invalid OAD:', err instanceof Error ? err.message : err);
+        console.error(`${icon.error} Invalid OAD:`, err instanceof Error ? err.message : err);
         process.exit(1);
     }
 });
@@ -99,15 +201,15 @@ program
     .description('Run agent in sandbox mode')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
     .action(async (opts) => {
-    console.log('🧪 Running agent in sandbox mode...');
+    console.log(`\n${icon.gear} Running agent in sandbox mode...`);
     const runtime = new runtime_1.AgentRuntime();
     await runtime.loadConfig(opts.file);
     const agent = await runtime.initialize();
     runtime.registerSkill(new customer_service_2.FAQSkill());
     runtime.registerSkill(new customer_service_2.HandoffSkill());
-    console.log(`✅ Agent "${agent.name}" initialized in sandbox.`);
+    console.log(`${icon.success} Agent "${color.bold(agent.name)}" initialized in sandbox.`);
     console.log(`   State: ${agent.state}`);
-    console.log(`   Send test message...`);
+    console.log(`   Sending test message...`);
     const response = await agent.handleMessage({
         id: 'test_1',
         role: 'user',
@@ -115,7 +217,7 @@ program
         timestamp: Date.now(),
     });
     console.log(`   Response: ${response.content}`);
-    console.log('✅ Sandbox test passed.');
+    console.log(`${icon.success} Sandbox test passed.\n`);
 });
 program
     .command('run')
@@ -129,18 +231,150 @@ program
     runtime.registerSkill(new customer_service_2.HandoffSkill());
     await runtime.start();
     const agent = runtime.getAgent();
-    console.log(`🚀 Agent "${agent?.name}" is running.`);
+    console.log(`\n${icon.rocket} Agent "${color.bold(agent?.name ?? 'unknown')}" is running.\n`);
+});
+program
+    .command('dev')
+    .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`);
+    let runtime = null;
+    const startAgent = async () => {
+        try {
+            if (runtime)
+                await runtime.stop();
+            runtime = new runtime_1.AgentRuntime();
+            await runtime.loadConfig(opts.file);
+            await runtime.initialize();
+            runtime.registerSkill(new customer_service_2.FAQSkill());
+            runtime.registerSkill(new customer_service_2.HandoffSkill());
+            await runtime.start();
+            const agent = runtime.getAgent();
+            console.log(`${icon.success} Agent "${color.bold(agent?.name ?? 'unknown')}" restarted.`);
+        }
+        catch (err) {
+            console.error(`${icon.error} Failed to start:`, err instanceof Error ? err.message : err);
+        }
+    };
+    await startAgent();
+    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...`);
+                await startAgent();
+            });
+        }
+    }
     process.on('SIGINT', async () => {
-        console.log('\nShutting down...');
-        await runtime.stop();
+        console.log(`\n${color.dim('Shutting down dev mode...')}`);
+        if (runtime)
+            await runtime.stop();
         process.exit(0);
     });
 });
 program
     .command('publish')
-    .description('Validate and package for OPC Registry (stub)')
-    .action(async () => {
-    console.log('📦 Publishing is not yet available. Coming soon in OPC Registry v1.');
+    .description('Validate and package for OPC Registry')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    try {
+        const runtime = new runtime_1.AgentRuntime();
+        const config = await runtime.loadConfig(opts.file);
+        const trust = config.spec.dtv?.trust?.level ?? 'sandbox';
+        console.log(`\n${icon.package} Publishing: ${color.bold(config.metadata.name)} v${config.metadata.version}`);
+        console.log(`   ${icon.success} OAD validation passed`);
+        console.log(`   🔐 Trust level: ${trust}`);
+        if (trust === 'sandbox') {
+            console.log(`   ${icon.warn} Trust level is 'sandbox'. Upgrade for marketplace listing.`);
+        }
+        const manifest = {
+            name: config.metadata.name,
+            version: config.metadata.version,
+            description: config.metadata.description,
+            author: config.metadata.author,
+            license: config.metadata.license,
+            trust,
+            category: config.metadata.marketplace?.category,
+            pricing: config.metadata.marketplace?.pricing ?? 'free',
+            tags: config.metadata.marketplace?.tags ?? [],
+            channels: config.spec.channels.map(c => c.type),
+            skills: config.spec.skills.map(s => s.name),
+            publishedAt: new Date().toISOString(),
+        };
+        fs.writeFileSync('opc-manifest.json', JSON.stringify(manifest, null, 2));
+        console.log(`   ${icon.file} Generated opc-manifest.json`);
+        console.log(`\n🚧 OPC Registry is coming soon. Manifest saved locally.\n`);
+    }
+    catch (err) {
+        console.error(`${icon.error} Publish failed:`, err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command('search')
+    .description('Search OPC Registry for agents and skills')
+    .argument('<query>', 'Search query')
+    .action(async (query) => {
+    console.log(`\n${icon.search} Searching OPC Registry for "${color.bold(query)}"...`);
+    console.log(`\n🚧 OPC Registry coming soon!`);
+    console.log(`   The marketplace is under development.`);
+    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`);
 });
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/core/agent.d.ts

@@ -8,12 +8,14 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private memory;
     private provider;
     private systemPrompt;
+    private historyLimit;
     constructor(options: {
         name: string;
         systemPrompt?: string;
         provider?: string;
         model?: string;
         memory?: MemoryStore;
+        historyLimit?: number;
     });
     get state(): AgentState;
     private transition;

package/dist/core/agent.js

@@ -12,12 +12,14 @@ class BaseAgent extends events_1.EventEmitter {
     memory;
     provider;
     systemPrompt;
+    historyLimit;
     constructor(options) {
         super();
         this.name = options.name;
         this.systemPrompt = options.systemPrompt ?? 'You are a helpful AI agent.';
         this.memory = options.memory ?? new memory_1.InMemoryStore();
         this.provider = (0, providers_1.createProvider)(options.provider ?? 'deepseek', options.model ?? 'deepseek-chat');
+        this.historyLimit = options.historyLimit ?? 50;
     }
     get state() {
         return this._state;
@@ -59,7 +61,7 @@ class BaseAgent extends events_1.EventEmitter {
         const context = {
             agentName: this.name,
             sessionId,
-            messages: await this.memory.getConversation(sessionId),
+            messages: (await this.memory.getConversation(sessionId)).slice(-this.historyLimit),
             memory: this.memory,
             metadata: {},
         };

package/dist/core/logger.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Structured logger with log levels.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare class Logger {
+    private context;
+    private level;
+    constructor(context: string, level?: LogLevel);
+    private shouldLog;
+    private format;
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+    setLevel(level: LogLevel): void;
+    child(context: string): Logger;
+}
+export declare const defaultLogger: Logger;
+//# sourceMappingURL=logger.d.ts.map