opc-agent 0.7.0 → 0.9.0

package/dist/channels/email.d.ts

@@ -0,0 +1,69 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+/**
+ * Email Channel — v0.8.0
+ * IMAP polling for incoming emails, SMTP for sending replies.
+ * Parses email threads as conversations.
+ */
+export interface EmailChannelConfig {
+    imap: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        tls?: boolean;
+        /** Mailbox to monitor (default: INBOX) */
+        mailbox?: string;
+        /** Poll interval in ms (default: 30000) */
+        pollInterval?: number;
+    };
+    smtp: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        tls?: boolean;
+        from: string;
+    };
+    /** Filter: only process emails matching these patterns */
+    filters?: {
+        from?: string[];
+        subject?: string[];
+    };
+}
+export interface EmailMessage {
+    messageId: string;
+    from: string;
+    to: string[];
+    cc?: string[];
+    subject: string;
+    body: string;
+    html?: string;
+    date: Date;
+    inReplyTo?: string;
+    references?: string[];
+    threadId?: string;
+}
+export declare class EmailChannel extends BaseChannel {
+    type: string;
+    private config;
+    private pollTimer;
+    private running;
+    private processedIds;
+    constructor(config: EmailChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Poll IMAP for new emails */
+    private poll;
+    /** Convert email to Message format */
+    private emailToMessage;
+    /** Check if email matches configured filters */
+    private matchesFilters;
+    /** Fetch emails via IMAP — stub for actual implementation */
+    private fetchEmails;
+    /** Send reply via SMTP — stub for actual implementation */
+    sendReply(originalEmail: EmailMessage, reply: Message): Promise<void>;
+    /** Send a standalone email */
+    send(to: string, subject: string, body: string): Promise<void>;
+}
+//# sourceMappingURL=email.d.ts.map

package/dist/channels/email.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailChannel = void 0;
+const index_1 = require("./index");
+class EmailChannel extends index_1.BaseChannel {
+    type = 'email';
+    config;
+    pollTimer = null;
+    running = false;
+    processedIds = new Set();
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        this.running = true;
+        const interval = this.config.imap.pollInterval ?? 30000;
+        // Initial poll
+        await this.poll();
+        // Set up recurring poll
+        this.pollTimer = setInterval(() => {
+            if (this.running)
+                this.poll().catch(console.error);
+        }, interval);
+    }
+    async stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    /** Poll IMAP for new emails */
+    async poll() {
+        // In production, use a library like `imapflow` or `imap-simple`
+        // This is the integration point — actual IMAP connection logic goes here
+        const emails = await this.fetchEmails();
+        for (const email of emails) {
+            if (this.processedIds.has(email.messageId))
+                continue;
+            this.processedIds.add(email.messageId);
+            if (!this.matchesFilters(email))
+                continue;
+            const message = this.emailToMessage(email);
+            if (this.handler) {
+                const reply = await this.handler(message);
+                await this.sendReply(email, reply);
+            }
+        }
+    }
+    /** Convert email to Message format */
+    emailToMessage(email) {
+        return {
+            id: email.messageId,
+            role: 'user',
+            content: email.body,
+            timestamp: email.date.getTime(),
+            metadata: {
+                channel: 'email',
+                from: email.from,
+                to: email.to,
+                subject: email.subject,
+                threadId: email.threadId ?? email.messageId,
+                inReplyTo: email.inReplyTo,
+            },
+        };
+    }
+    /** Check if email matches configured filters */
+    matchesFilters(email) {
+        if (!this.config.filters)
+            return true;
+        if (this.config.filters.from?.length) {
+            const fromMatch = this.config.filters.from.some((f) => email.from.toLowerCase().includes(f.toLowerCase()));
+            if (!fromMatch)
+                return false;
+        }
+        if (this.config.filters.subject?.length) {
+            const subjectMatch = this.config.filters.subject.some((s) => email.subject.toLowerCase().includes(s.toLowerCase()));
+            if (!subjectMatch)
+                return false;
+        }
+        return true;
+    }
+    /** Fetch emails via IMAP — stub for actual implementation */
+    async fetchEmails() {
+        // TODO: Implement with imapflow or similar library
+        // const { ImapFlow } = await import('imapflow');
+        // const client = new ImapFlow({ ...this.config.imap });
+        // await client.connect();
+        // ...
+        return [];
+    }
+    /** Send reply via SMTP — stub for actual implementation */
+    async sendReply(originalEmail, reply) {
+        // TODO: Implement with nodemailer or similar library
+        // const nodemailer = await import('nodemailer');
+        // const transport = nodemailer.createTransport({ ...this.config.smtp });
+        // await transport.sendMail({
+        //   from: this.config.smtp.from,
+        //   to: originalEmail.from,
+        //   subject: `Re: ${originalEmail.subject}`,
+        //   text: reply.content,
+        //   inReplyTo: originalEmail.messageId,
+        //   references: [originalEmail.messageId],
+        // });
+        void originalEmail;
+        void reply;
+    }
+    /** Send a standalone email */
+    async send(to, subject, body) {
+        void to;
+        void subject;
+        void body;
+        // TODO: Implement with nodemailer
+    }
+}
+exports.EmailChannel = EmailChannel;
+//# sourceMappingURL=email.js.map

package/dist/channels/slack.d.ts

@@ -0,0 +1,62 @@
+import { BaseChannel } from './index';
+/**
+ * Slack Channel — v0.8.0
+ * Slack Bot with Socket Mode / Events API support, threads, and slash commands.
+ */
+export interface SlackChannelConfig {
+    /** Bot token (xoxb-...) */
+    botToken: string;
+    /** App-level token for Socket Mode (xapp-...) */
+    appToken?: string;
+    /** Signing secret for Events API verification */
+    signingSecret?: string;
+    /** Use Socket Mode (true) or Events API (false) */
+    socketMode?: boolean;
+    /** Port for Events API webhook server (default: 3001) */
+    port?: number;
+    /** Slash commands to register */
+    slashCommands?: SlashCommandConfig[];
+}
+export interface SlashCommandConfig {
+    command: string;
+    description: string;
+    handler?: (payload: SlashCommandPayload) => Promise<string>;
+}
+export interface SlashCommandPayload {
+    command: string;
+    text: string;
+    userId: string;
+    channelId: string;
+    triggerId: string;
+}
+export interface SlackMessageEvent {
+    type: string;
+    channel: string;
+    user: string;
+    text: string;
+    ts: string;
+    threadTs?: string;
+    botId?: string;
+}
+export declare class SlackChannel extends BaseChannel {
+    type: string;
+    private config;
+    private running;
+    private slashHandlers;
+    constructor(config: SlackChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Start Socket Mode connection */
+    private startSocketMode;
+    /** Start Events API HTTP server */
+    private startEventsAPI;
+    /** Handle incoming Slack message */
+    handleMessage(event: SlackMessageEvent): Promise<void>;
+    /** Handle slash command */
+    handleSlashCommand(payload: SlashCommandPayload): Promise<string>;
+    /** Convert Slack event to Message */
+    private slackToMessage;
+    /** Send a message to a Slack channel */
+    sendMessage(channel: string, text: string, threadTs?: string): Promise<void>;
+}
+//# sourceMappingURL=slack.d.ts.map

package/dist/channels/slack.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackChannel = void 0;
+const index_1 = require("./index");
+class SlackChannel extends index_1.BaseChannel {
+    type = 'slack';
+    config;
+    running = false;
+    slashHandlers = new Map();
+    constructor(config) {
+        super();
+        this.config = config;
+        for (const cmd of config.slashCommands ?? []) {
+            this.slashHandlers.set(cmd.command, cmd);
+        }
+    }
+    async start() {
+        this.running = true;
+        if (this.config.socketMode && this.config.appToken) {
+            await this.startSocketMode();
+        }
+        else {
+            await this.startEventsAPI();
+        }
+    }
+    async stop() {
+        this.running = false;
+        // Cleanup connections
+    }
+    /** Start Socket Mode connection */
+    async startSocketMode() {
+        // TODO: Implement with @slack/socket-mode
+        // const { SocketModeClient } = await import('@slack/socket-mode');
+        // const client = new SocketModeClient({ appToken: this.config.appToken! });
+        // client.on('message', (event) => this.handleMessage(event));
+        // await client.start();
+    }
+    /** Start Events API HTTP server */
+    async startEventsAPI() {
+        // TODO: Implement with express or http
+        // const port = this.config.port ?? 3001;
+        // Listen for POST /slack/events and /slack/commands
+    }
+    /** Handle incoming Slack message */
+    async handleMessage(event) {
+        // Ignore bot messages
+        if (event.botId)
+            return;
+        const message = this.slackToMessage(event);
+        if (this.handler) {
+            const reply = await this.handler(message);
+            await this.sendMessage(event.channel, reply.content, event.threadTs ?? event.ts);
+        }
+    }
+    /** Handle slash command */
+    async handleSlashCommand(payload) {
+        const cmd = this.slashHandlers.get(payload.command);
+        if (cmd?.handler) {
+            return cmd.handler(payload);
+        }
+        // Default: pass to message handler
+        const message = {
+            id: `slack-cmd-${Date.now()}`,
+            role: 'user',
+            content: `${payload.command} ${payload.text}`.trim(),
+            timestamp: Date.now(),
+            metadata: {
+                channel: 'slack',
+                channelId: payload.channelId,
+                userId: payload.userId,
+                isSlashCommand: true,
+            },
+        };
+        if (this.handler) {
+            const reply = await this.handler(message);
+            return reply.content;
+        }
+        return 'Command received.';
+    }
+    /** Convert Slack event to Message */
+    slackToMessage(event) {
+        return {
+            id: event.ts,
+            role: 'user',
+            content: event.text,
+            timestamp: parseFloat(event.ts) * 1000,
+            metadata: {
+                channel: 'slack',
+                channelId: event.channel,
+                userId: event.user,
+                threadTs: event.threadTs,
+            },
+        };
+    }
+    /** Send a message to a Slack channel */
+    async sendMessage(channel, text, threadTs) {
+        // TODO: Implement with @slack/web-api
+        // const { WebClient } = await import('@slack/web-api');
+        // const client = new WebClient(this.config.botToken);
+        // await client.chat.postMessage({ channel, text, thread_ts: threadTs });
+        void channel;
+        void text;
+        void threadTs;
+    }
+}
+exports.SlackChannel = SlackChannel;
+//# sourceMappingURL=slack.js.map

package/dist/channels/wechat.d.ts

@@ -0,0 +1,62 @@
+import { BaseChannel } from './index';
+/**
+ * WeChat Channel (Stub) — v0.8.0
+ * WeChat Official Account message handling, template messages, QR code login.
+ */
+export interface WeChatChannelConfig {
+    /** WeChat Official Account AppID */
+    appId: string;
+    /** WeChat Official Account AppSecret */
+    appSecret: string;
+    /** Verification token for message validation */
+    token: string;
+    /** AES encoding key for encrypted messages */
+    encodingAESKey?: string;
+    /** HTTP server port (default: 3002) */
+    port?: number;
+}
+export interface WeChatMessage {
+    toUserName: string;
+    fromUserName: string;
+    createTime: number;
+    msgType: 'text' | 'image' | 'voice' | 'video' | 'event';
+    content?: string;
+    msgId?: string;
+    event?: string;
+    eventKey?: string;
+}
+export interface TemplateMessageData {
+    toUser: string;
+    templateId: string;
+    url?: string;
+    data: Record<string, {
+        value: string;
+        color?: string;
+    }>;
+}
+export declare class WeChatChannel extends BaseChannel {
+    type: string;
+    private config;
+    private accessToken;
+    private tokenExpiry;
+    constructor(config: WeChatChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Get or refresh access token */
+    getAccessToken(): Promise<string>;
+    /** Handle incoming WeChat message */
+    handleMessage(wxMsg: WeChatMessage): Promise<string>;
+    /** Handle WeChat events (subscribe, scan, etc.) */
+    private handleEvent;
+    /** Convert WeChat message to internal Message */
+    private wechatToMessage;
+    /** Send template message */
+    sendTemplateMessage(data: TemplateMessageData): Promise<boolean>;
+    /** Generate QR code for login (stub) */
+    generateLoginQR(): Promise<{
+        ticket: string;
+        url: string;
+        expireSeconds: number;
+    }>;
+}
+//# sourceMappingURL=wechat.d.ts.map

package/dist/channels/wechat.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeChatChannel = void 0;
+const index_1 = require("./index");
+class WeChatChannel extends index_1.BaseChannel {
+    type = 'wechat';
+    config;
+    accessToken = null;
+    tokenExpiry = 0;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        // TODO: Start HTTP server to receive WeChat push messages
+        // 1. Verify signature on GET requests
+        // 2. Parse XML messages on POST requests
+        // 3. Route to handler and reply with XML
+    }
+    async stop() {
+        // TODO: Stop HTTP server
+    }
+    /** Get or refresh access token */
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiry) {
+            return this.accessToken;
+        }
+        // TODO: Implement token refresh
+        // const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${this.config.appId}&secret=${this.config.appSecret}`;
+        // const res = await fetch(url);
+        // const data = await res.json();
+        // this.accessToken = data.access_token;
+        // this.tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
+        return this.accessToken ?? '';
+    }
+    /** Handle incoming WeChat message */
+    async handleMessage(wxMsg) {
+        if (wxMsg.msgType === 'event') {
+            return this.handleEvent(wxMsg);
+        }
+        const message = this.wechatToMessage(wxMsg);
+        if (this.handler) {
+            const reply = await this.handler(message);
+            return reply.content;
+        }
+        return '';
+    }
+    /** Handle WeChat events (subscribe, scan, etc.) */
+    handleEvent(wxMsg) {
+        switch (wxMsg.event) {
+            case 'subscribe':
+                return 'Welcome! How can I help you?';
+            case 'SCAN':
+                return `QR code scanned: ${wxMsg.eventKey}`;
+            default:
+                return '';
+        }
+    }
+    /** Convert WeChat message to internal Message */
+    wechatToMessage(wxMsg) {
+        return {
+            id: wxMsg.msgId ?? `wx-${wxMsg.createTime}`,
+            role: 'user',
+            content: wxMsg.content ?? '',
+            timestamp: wxMsg.createTime * 1000,
+            metadata: {
+                channel: 'wechat',
+                fromUser: wxMsg.fromUserName,
+                toUser: wxMsg.toUserName,
+                msgType: wxMsg.msgType,
+            },
+        };
+    }
+    /** Send template message */
+    async sendTemplateMessage(data) {
+        // TODO: Implement
+        // const token = await this.getAccessToken();
+        // const url = `https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=${token}`;
+        // const res = await fetch(url, {
+        //   method: 'POST',
+        //   body: JSON.stringify({
+        //     touser: data.toUser,
+        //     template_id: data.templateId,
+        //     url: data.url,
+        //     data: data.data,
+        //   }),
+        // });
+        void data;
+        return true;
+    }
+    /** Generate QR code for login (stub) */
+    async generateLoginQR() {
+        // TODO: Implement with WeChat QR code API
+        // const token = await this.getAccessToken();
+        // POST to https://api.weixin.qq.com/cgi-bin/qrcode/create
+        return {
+            ticket: 'stub-ticket',
+            url: 'https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=stub-ticket',
+            expireSeconds: 300,
+        };
+    }
+}
+exports.WeChatChannel = WeChatChannel;
+//# sourceMappingURL=wechat.js.map

package/dist/cli.js

@@ -50,7 +50,11 @@ 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 data_analyst_1 = require("./templates/data-analyst");
+const teacher_1 = require("./templates/teacher");
 const analytics_1 = require("./analytics");
+const analytics_engine_1 = require("./core/analytics-engine");
+const testing_1 = require("./testing");
 const openclaw_1 = require("./deploy/openclaw");
 const hermes_1 = require("./deploy/hermes");
 const workflow_1 = require("./core/workflow");
@@ -90,6 +94,8 @@ const TEMPLATES = {
     '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 },
+    'data-analyst': { label: 'Data Analyst - data querying + visualization + insights', factory: data_analyst_1.createDataAnalystConfig },
+    'teacher': { label: 'Teacher - lesson planning + quizzes + concept explanation', factory: teacher_1.createTeacherConfig },
 };
 async function promptUser(question, defaultValue) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -113,7 +119,7 @@ async function select(question, options) {
 program
     .name('opc')
     .description('OPC Agent - Open Agent Framework for business workstations')
-    .version('0.6.0');
+    .version('0.9.0');
 // ── Init command ─────────────────────────────────────────────
 program
     .command('init')
@@ -396,25 +402,47 @@ program
 // ── Test command ─────────────────────────────────────────────
 program
     .command('test')
-    .description('Run agent in sandbox mode')
+    .description('Run agent tests defined in OAD or tests.yaml')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .option('--json', 'Output as JSON')
     .action(async (opts) => {
     loadDotEnv();
-    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();
-    console.log(`${icon.success} Agent "${color.bold(agent.name)}" initialized in sandbox.`);
-    console.log(`   State: ${agent.state}`);
-    console.log(`   Sending test message...`);
-    const response = await agent.handleMessage({
-        id: 'test_1',
-        role: 'user',
-        content: 'Hello! What can you help me with?',
-        timestamp: Date.now(),
-    });
-    console.log(`   Response: ${response.content.slice(0, 200)}`);
-    console.log(`${icon.success} Sandbox test passed.\n`);
+    console.log(`\n${icon.gear} Running agent tests...\n`);
+    try {
+        const report = await (0, testing_1.runTests)(opts.file);
+        if (opts.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log((0, testing_1.formatReport)(report));
+        }
+        process.exit(report.failed > 0 ? 1 : 0);
+    }
+    catch (err) {
+        console.error(`${icon.error} Test failed:`, err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ── Analytics command ────────────────────────────────────────
+program
+    .command('analytics')
+    .description('Show agent analytics and usage stats')
+    .option('--json', 'Output as JSON')
+    .option('--clear', 'Clear analytics data')
+    .action(async (opts) => {
+    const engine = new analytics_engine_1.AnalyticsEngine('.');
+    if (opts.clear) {
+        engine.clear();
+        console.log(`${icon.success} Analytics data cleared.`);
+        return;
+    }
+    const stats = engine.getStats();
+    if (opts.json) {
+        console.log(JSON.stringify(stats, null, 2));
+    }
+    else {
+        console.log(analytics_engine_1.AnalyticsEngine.formatStats(stats));
+    }
 });
 // ── Dev command ──────────────────────────────────────────────
 program

package/dist/core/analytics-engine.d.ts

@@ -0,0 +1,51 @@
+export interface AnalyticsEvent {
+    type: 'message' | 'llm_call' | 'tool_use' | 'error';
+    timestamp: number;
+    data: Record<string, any>;
+}
+export interface AnalyticsStats {
+    totalMessages: number;
+    totalLLMCalls: number;
+    totalToolUses: number;
+    totalErrors: number;
+    avgResponseTimeMs: number;
+    totalTokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    topSkills: {
+        name: string;
+        count: number;
+    }[];
+    topErrors: {
+        message: string;
+        count: number;
+    }[];
+    messagesPerDay: Record<string, number>;
+    period: {
+        from: number;
+        to: number;
+    };
+}
+export declare class AnalyticsEngine {
+    private dataDir;
+    private eventsFile;
+    private events;
+    constructor(dataDir?: string);
+    private load;
+    private save;
+    track(type: AnalyticsEvent['type'], data: Record<string, any>): void;
+    trackMessage(userId: string, responseTimeMs: number, tokensIn: number, tokensOut: number): void;
+    trackLLMCall(provider: string, model: string, tokensIn: number, tokensOut: number, latencyMs: number): void;
+    trackToolUse(toolName: string, success: boolean, latencyMs: number): void;
+    trackError(error: string, context?: string): void;
+    getStats(fromTs?: number, toTs?: number): AnalyticsStats;
+    getRecentEvents(limit?: number): AnalyticsEvent[];
+    clear(): void;
+    /**
+     * Format stats for CLI display.
+     */
+    static formatStats(stats: AnalyticsStats): string;
+}
+//# sourceMappingURL=analytics-engine.d.ts.map