opc-agent 1.3.2 → 2.0.0

package/dist/templates/data-analyst.js

@@ -33,11 +33,11 @@ class InsightSkill extends base_1.BaseSkill {
     }
 }
 exports.InsightSkill = InsightSkill;
-exports.DATA_ANALYST_SYSTEM_PROMPT = `You are a professional data analyst assistant. Your goals:
-1. Help users query, transform, and analyze data
-2. Create clear visualizations and summaries
-3. Identify trends, patterns, and anomalies
-4. Explain findings in plain language
+exports.DATA_ANALYST_SYSTEM_PROMPT = `You are a professional data analyst assistant. Your goals:
+1. Help users query, transform, and analyze data
+2. Create clear visualizations and summaries
+3. Identify trends, patterns, and anomalies
+4. Explain findings in plain language
 Be precise with numbers, always cite your data source, and suggest next steps for deeper analysis.`;
 function createDataAnalystConfig() {
     return {
@@ -60,10 +60,6 @@ function createDataAnalystConfig() {
             ],
             channels: [{ type: 'web', port: 3000 }],
             memory: { shortTerm: true, longTerm: true },
-            dtv: {
-                trust: { level: 'sandbox' },
-                value: { metrics: ['queries_processed', 'insights_generated'] },
-            },
         },
     };
 }

package/dist/templates/knowledge-base.d.ts

@@ -31,14 +31,6 @@ export declare function createKnowledgeBaseConfig(): {
                 collection: string;
             };
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=knowledge-base.d.ts.map

package/dist/templates/knowledge-base.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KNOWLEDGE_BASE_SYSTEM_PROMPT = void 0;
 exports.createKnowledgeBaseConfig = createKnowledgeBaseConfig;
-exports.KNOWLEDGE_BASE_SYSTEM_PROMPT = `You are a knowledge base assistant. Answer questions using the company documents
-and knowledge provided to you. If you don't have enough information, say so honestly.
+exports.KNOWLEDGE_BASE_SYSTEM_PROMPT = `You are a knowledge base assistant. Answer questions using the company documents
+and knowledge provided to you. If you don't have enough information, say so honestly.
 Always cite sources when possible. Be accurate and concise.`;
 function createKnowledgeBaseConfig() {
     return {
@@ -25,10 +25,6 @@ function createKnowledgeBaseConfig() {
             ],
             channels: [{ type: 'web', port: 3000 }],
             memory: { shortTerm: true, longTerm: { provider: 'deepbrain', collection: 'company-knowledge' } },
-            dtv: {
-                trust: { level: 'sandbox' },
-                value: { metrics: ['queries_answered', 'docs_indexed'] },
-            },
         },
     };
 }

package/dist/templates/sales-assistant.d.ts

@@ -43,14 +43,6 @@ export declare function createSalesAssistantConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=sales-assistant.d.ts.map

package/dist/templates/sales-assistant.js

@@ -43,10 +43,10 @@ class LeadCaptureSkill extends base_1.BaseSkill {
     }
 }
 exports.LeadCaptureSkill = LeadCaptureSkill;
-exports.SALES_ASSISTANT_SYSTEM_PROMPT = `You are a professional sales assistant. Your goals:
-1. Answer product questions accurately and enthusiastically
-2. Capture leads by collecting name, email, and company info
-3. Book appointments when prospects are ready
+exports.SALES_ASSISTANT_SYSTEM_PROMPT = `You are a professional sales assistant. Your goals:
+1. Answer product questions accurately and enthusiastically
+2. Capture leads by collecting name, email, and company info
+3. Book appointments when prospects are ready
 Be friendly, persuasive but not pushy. Always provide value first.`;
 function createSalesAssistantConfig() {
     return {
@@ -69,10 +69,6 @@ function createSalesAssistantConfig() {
             ],
             channels: [{ type: 'web', port: 3000 }],
             memory: { shortTerm: true, longTerm: false },
-            dtv: {
-                trust: { level: 'sandbox' },
-                value: { metrics: ['leads_captured', 'appointments_booked'] },
-            },
         },
     };
 }

package/dist/templates/teacher.d.ts

@@ -45,14 +45,6 @@ export declare function createTeacherConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=teacher.d.ts.map

package/dist/templates/teacher.js

@@ -39,12 +39,12 @@ class ExplainSkill extends base_1.BaseSkill {
     }
 }
 exports.ExplainSkill = ExplainSkill;
-exports.TEACHER_SYSTEM_PROMPT = `You are a patient and encouraging teacher assistant. Your goals:
-1. Create engaging lesson plans tailored to student level
-2. Generate quizzes and assessments with answer keys
-3. Explain complex concepts using analogies and examples
-4. Provide constructive feedback and encouragement
-5. Adapt teaching style to different learning preferences
+exports.TEACHER_SYSTEM_PROMPT = `You are a patient and encouraging teacher assistant. Your goals:
+1. Create engaging lesson plans tailored to student level
+2. Generate quizzes and assessments with answer keys
+3. Explain complex concepts using analogies and examples
+4. Provide constructive feedback and encouragement
+5. Adapt teaching style to different learning preferences
 Be patient, use clear language, and always check for understanding. Use the Socratic method when appropriate.`;
 function createTeacherConfig() {
     return {
@@ -68,10 +68,6 @@ function createTeacherConfig() {
             ],
             channels: [{ type: 'web', port: 3000 }],
             memory: { shortTerm: true, longTerm: true },
-            dtv: {
-                trust: { level: 'sandbox' },
-                value: { metrics: ['lessons_created', 'quizzes_generated', 'concepts_explained'] },
-            },
         },
     };
 }

package/dist/tools/builtin/datetime.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const datetimeTool: MCPTool;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/tools/builtin/datetime.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datetimeTool = void 0;
+exports.datetimeTool = {
+    name: 'datetime',
+    description: 'Get current date, time, timezone info',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', default: 'iso' },
+            timezone: { type: 'string' },
+        },
+    },
+    async execute(input) {
+        const now = new Date();
+        const timezone = input.timezone;
+        const format = input.format || 'iso';
+        let content;
+        if (format === 'iso') {
+            content = now.toISOString();
+        }
+        else if (format === 'locale') {
+            content = timezone
+                ? now.toLocaleString('en-US', { timeZone: timezone })
+                : now.toLocaleString();
+        }
+        else if (format === 'unix') {
+            content = String(Math.floor(now.getTime() / 1000));
+        }
+        else {
+            content = now.toISOString();
+        }
+        return {
+            content: JSON.stringify({
+                iso: now.toISOString(),
+                unix: Math.floor(now.getTime() / 1000),
+                formatted: content,
+                timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+            }),
+            isError: false,
+        };
+    },
+};
+//# sourceMappingURL=datetime.js.map

package/dist/tools/builtin/file.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const fileTool: MCPTool;
+//# sourceMappingURL=file.d.ts.map

package/dist/tools/builtin/file.js

@@ -0,0 +1,151 @@
+"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.fileTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function resolveSafe(basePath, targetPath) {
+    const resolved = path.resolve(basePath, targetPath);
+    if (!resolved.startsWith(path.resolve(basePath)))
+        return null;
+    return resolved;
+}
+function searchFiles(dir, query, results = [], maxResults = 20) {
+    if (results.length >= maxResults)
+        return results;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                break;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git')
+                    continue;
+                searchFiles(full, query, results, maxResults);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].includes(query)) {
+                            results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
+                            if (results.length >= maxResults)
+                                break;
+                        }
+                    }
+                }
+                catch { /* skip binary/unreadable */ }
+            }
+        }
+    }
+    catch { /* skip inaccessible dirs */ }
+    return results;
+}
+exports.fileTool = {
+    name: 'file_operations',
+    description: 'Read, write, list, and search files in the workspace',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['read', 'write', 'list', 'search', 'exists'] },
+            path: { type: 'string' },
+            content: { type: 'string' },
+            query: { type: 'string' },
+        },
+        required: ['action'],
+    },
+    async execute(input, context) {
+        const action = input.action;
+        const workspace = process.cwd();
+        const targetPath = input.path;
+        if (action === 'search') {
+            const query = input.query;
+            if (!query)
+                return { content: 'query is required for search', isError: true };
+            const results = searchFiles(workspace, query);
+            return { content: results.length ? results.join('\n') : 'No matches found', isError: false };
+        }
+        if (action === 'list') {
+            const dir = targetPath ? resolveSafe(workspace, targetPath) : workspace;
+            if (!dir)
+                return { content: 'Path outside workspace', isError: true };
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                const listing = entries.map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`).join('\n');
+                return { content: listing || '(empty directory)', isError: false };
+            }
+            catch (err) {
+                return { content: `Error listing directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+            }
+        }
+        if (!targetPath)
+            return { content: 'path is required', isError: true };
+        const resolved = resolveSafe(workspace, targetPath);
+        if (!resolved)
+            return { content: 'Path outside workspace', isError: true };
+        switch (action) {
+            case 'read': {
+                try {
+                    const content = fs.readFileSync(resolved, 'utf-8');
+                    return { content: content.slice(0, 50000), isError: false };
+                }
+                catch (err) {
+                    return { content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+                }
+            }
+            case 'write': {
+                const content = input.content;
+                if (content === undefined)
+                    return { content: 'content is required for write', isError: true };
+                try {
+                    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+                    fs.writeFileSync(resolved, content, 'utf-8');
+                    return { content: `Written ${content.length} bytes to ${targetPath}`, isError: false };
+                }
+                catch (err) {
+                    return { content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+                }
+            }
+            case 'exists': {
+                return { content: String(fs.existsSync(resolved)), isError: false };
+            }
+            default:
+                return { content: `Unknown action: ${action}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=file.js.map

package/dist/tools/builtin/index.d.ts

@@ -0,0 +1,15 @@
+import type { MCPTool } from '../mcp';
+import { fileTool } from './file';
+import { webTool } from './web';
+import { shellTool } from './shell';
+import { datetimeTool } from './datetime';
+export { fileTool, webTool, shellTool, datetimeTool };
+/**
+ * Get all built-in tools.
+ */
+export declare function getBuiltinTools(): MCPTool[];
+/**
+ * Get specific built-in tools by name. If no names given, returns all.
+ */
+export declare function getBuiltinToolsByName(names?: string[]): MCPTool[];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/builtin/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datetimeTool = exports.shellTool = exports.webTool = exports.fileTool = void 0;
+exports.getBuiltinTools = getBuiltinTools;
+exports.getBuiltinToolsByName = getBuiltinToolsByName;
+const file_1 = require("./file");
+Object.defineProperty(exports, "fileTool", { enumerable: true, get: function () { return file_1.fileTool; } });
+const web_1 = require("./web");
+Object.defineProperty(exports, "webTool", { enumerable: true, get: function () { return web_1.webTool; } });
+const shell_1 = require("./shell");
+Object.defineProperty(exports, "shellTool", { enumerable: true, get: function () { return shell_1.shellTool; } });
+const datetime_1 = require("./datetime");
+Object.defineProperty(exports, "datetimeTool", { enumerable: true, get: function () { return datetime_1.datetimeTool; } });
+const ALL_BUILTIN_TOOLS = [file_1.fileTool, web_1.webTool, shell_1.shellTool, datetime_1.datetimeTool];
+const BUILTIN_MAP = new Map(ALL_BUILTIN_TOOLS.map(t => [t.name, t]));
+/**
+ * Get all built-in tools.
+ */
+function getBuiltinTools() {
+    return [...ALL_BUILTIN_TOOLS];
+}
+/**
+ * Get specific built-in tools by name. If no names given, returns all.
+ */
+function getBuiltinToolsByName(names) {
+    if (!names || names.length === 0)
+        return getBuiltinTools();
+    return names.map(n => BUILTIN_MAP.get(n)).filter((t) => !!t);
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/builtin/shell.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const shellTool: MCPTool;
+//# sourceMappingURL=shell.d.ts.map

package/dist/tools/builtin/shell.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellTool = void 0;
+const child_process_1 = require("child_process");
+exports.shellTool = {
+    name: 'shell_exec',
+    description: 'Execute a shell command (sandboxed to workspace)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string' },
+            timeout: { type: 'number', default: 30000 },
+        },
+        required: ['command'],
+    },
+    async execute(input) {
+        const command = input.command;
+        const timeout = input.timeout || 30000;
+        const workspace = process.cwd();
+        // Block path traversal attempts
+        if (command.includes('..')) {
+            return { content: 'Commands with ".." are not allowed for security', isError: true };
+        }
+        try {
+            const output = (0, child_process_1.execSync)(command, {
+                cwd: workspace,
+                timeout,
+                encoding: 'utf-8',
+                maxBuffer: 1024 * 1024,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const result = (output || '').slice(0, 5000);
+            return { content: result || '(no output)', isError: false };
+        }
+        catch (err) {
+            const stderr = err.stderr ? String(err.stderr).slice(0, 2500) : '';
+            const stdout = err.stdout ? String(err.stdout).slice(0, 2500) : '';
+            const output = [stdout, stderr].filter(Boolean).join('\n') || err.message;
+            return { content: `Command failed: ${output.slice(0, 5000)}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=shell.js.map

package/dist/tools/builtin/web.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const webTool: MCPTool;
+//# sourceMappingURL=web.d.ts.map

package/dist/tools/builtin/web.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webTool = void 0;
+exports.webTool = {
+    name: 'web_fetch',
+    description: 'Fetch content from a URL',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: { type: 'string' },
+            method: { type: 'string', enum: ['GET', 'POST'], default: 'GET' },
+            maxLength: { type: 'number', default: 5000 },
+        },
+        required: ['url'],
+    },
+    async execute(input) {
+        const url = input.url;
+        const method = input.method || 'GET';
+        const maxLength = input.maxLength || 5000;
+        try {
+            const response = await fetch(url, { method, signal: AbortSignal.timeout(15000) });
+            const text = await response.text();
+            const truncated = text.length > maxLength ? text.slice(0, maxLength) + '\n...[truncated]' : text;
+            return {
+                content: `Status: ${response.status}\n\n${truncated}`,
+                isError: false,
+            };
+        }
+        catch (err) {
+            return {
+                content: `Fetch error: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
+        }
+    },
+};
+//# sourceMappingURL=web.js.map

package/dist/tools/mcp-client.d.ts

@@ -0,0 +1,24 @@
+import type { MCPToolDefinition, MCPToolResult } from './mcp';
+export interface MCPServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare class MCPClient {
+    private process;
+    private config;
+    private nextId;
+    private pending;
+    private buffer;
+    private connected;
+    connect(config: MCPServerConfig): Promise<void>;
+    private processBuffer;
+    private sendRequest;
+    private sendNotification;
+    listTools(): Promise<MCPToolDefinition[]>;
+    callTool(name: string, input: Record<string, unknown>): Promise<MCPToolResult>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/tools/mcp-client.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = void 0;
+const child_process_1 = require("child_process");
+class MCPClient {
+    process = null;
+    config = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = '';
+    connected = false;
+    async connect(config) {
+        this.config = config;
+        this.process = (0, child_process_1.spawn)(config.command, config.args ?? [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...config.env },
+        });
+        this.process.stdout.on('data', (data) => {
+            this.buffer += data.toString();
+            this.processBuffer();
+        });
+        this.process.on('error', (err) => {
+            for (const [, p] of this.pending)
+                p.reject(err);
+            this.pending.clear();
+        });
+        this.process.on('exit', () => {
+            this.connected = false;
+            for (const [, p] of this.pending)
+                p.reject(new Error('MCP server exited'));
+            this.pending.clear();
+        });
+        // Send initialize
+        await this.sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'opc-agent', version: '0.7.0' },
+        });
+        // Send initialized notification
+        this.sendNotification('notifications/initialized', {});
+        this.connected = true;
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (msg.id !== undefined && this.pending.has(msg.id)) {
+                    const p = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error) {
+                        p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+                    }
+                    else {
+                        p.resolve(msg.result);
+                    }
+                }
+            }
+            catch { /* skip non-JSON lines */ }
+        }
+    }
+    sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            if (!this.process?.stdin?.writable) {
+                reject(new Error('MCP server not connected'));
+                return;
+            }
+            const id = this.nextId++;
+            this.pending.set(id, { resolve, reject });
+            const msg = JSON.stringify({ jsonrpc: '2.0', method, params: params ?? {}, id });
+            this.process.stdin.write(msg + '\n');
+            // Timeout after 30s
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timed out: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.process?.stdin?.writable)
+            return;
+        const msg = JSON.stringify({ jsonrpc: '2.0', method, params });
+        this.process.stdin.write(msg + '\n');
+    }
+    async listTools() {
+        const result = await this.sendRequest('tools/list');
+        return (result.tools ?? []).map((t) => ({
+            name: t.name,
+            description: t.description ?? '',
+            inputSchema: t.inputSchema ?? {},
+        }));
+    }
+    async callTool(name, input) {
+        const result = await this.sendRequest('tools/call', { name, arguments: input });
+        const content = (result.content ?? [])
+            .map((c) => c.text ?? JSON.stringify(c))
+            .join('\n');
+        return { content, isError: result.isError ?? false };
+    }
+    async disconnect() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this.connected = false;
+        this.pending.clear();
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.MCPClient = MCPClient;
+//# sourceMappingURL=mcp-client.js.map