opc-agent 1.4.0 → 2.0.0

package/dist/skills/auto-learn.js

@@ -0,0 +1,257 @@
+"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.SkillLearner = void 0;
+exports.skillToMarkdown = skillToMarkdown;
+exports.parseSkillMarkdown = parseSkillMarkdown;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SKILL_EXTRACTION_PROMPT = `Analyze this conversation and determine if it represents a repeatable task that should be saved as a reusable skill.
+
+Criteria for creating a skill:
+1. The task is specific and well-defined
+2. It could reasonably happen again
+3. The solution has clear steps
+
+If yes, extract:
+- name: short kebab-case name
+- description: one-line description
+- trigger: regex pattern or keywords that would identify this task
+- instructions: step-by-step instructions to complete the task
+- examples: 2-3 example user inputs that would trigger this skill
+
+If this is just casual chat or a one-off question, return null.
+
+Respond in JSON format only: { "shouldCreate": boolean, "skill": { "name": string, "description": string, "trigger": string, "instructions": string, "examples": string[] } | null }
+
+Conversation:
+`;
+const SKILL_IMPROVEMENT_PROMPT = `This skill was just used. Based on the outcome, suggest improvements:
+
+Current skill:
+`;
+const SKILL_IMPROVEMENT_SUFFIX = `
+
+Respond in JSON only: { "shouldImprove": boolean, "improvements": { "instructions"?: string, "trigger"?: string, "examples"?: string[] } | null }`;
+class SkillLearner {
+    skillsDir;
+    skills = [];
+    loaded = false;
+    constructor(skillsDir) {
+        this.skillsDir = skillsDir;
+    }
+    async analyzeForSkillCreation(conversation, provider) {
+        const conversationText = conversation
+            .map((m) => `${m.role}: ${m.content}`)
+            .join('\n');
+        const prompt = SKILL_EXTRACTION_PROMPT + conversationText;
+        try {
+            const response = await provider.chat([{ id: 'analysis', role: 'user', content: prompt, timestamp: Date.now() }], 'You are a skill extraction assistant. Respond only with valid JSON.');
+            const json = extractJson(response);
+            if (!json || !json.shouldCreate || !json.skill)
+                return null;
+            const skill = {
+                name: json.skill.name,
+                description: json.skill.description,
+                trigger: json.skill.trigger,
+                instructions: json.skill.instructions,
+                examples: json.skill.examples || [],
+                createdAt: new Date(),
+                usageCount: 0,
+                version: 1,
+            };
+            return skill;
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveSkill(skill) {
+        fs.mkdirSync(this.skillsDir, { recursive: true });
+        const filePath = path.join(this.skillsDir, `${skill.name}.md`);
+        fs.writeFileSync(filePath, skillToMarkdown(skill), 'utf-8');
+        // Update cache
+        const idx = this.skills.findIndex((s) => s.name === skill.name);
+        if (idx >= 0) {
+            this.skills[idx] = skill;
+        }
+        else {
+            this.skills.push(skill);
+        }
+    }
+    async loadLearnedSkills() {
+        if (!fs.existsSync(this.skillsDir))
+            return [];
+        const files = fs.readdirSync(this.skillsDir).filter((f) => f.endsWith('.md'));
+        this.skills = files
+            .map((f) => {
+            try {
+                const content = fs.readFileSync(path.join(this.skillsDir, f), 'utf-8');
+                return parseSkillMarkdown(content);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null);
+        this.loaded = true;
+        return this.skills;
+    }
+    matchSkill(message) {
+        if (!this.loaded)
+            return null;
+        for (const skill of this.skills) {
+            try {
+                const regex = new RegExp(skill.trigger, 'i');
+                if (regex.test(message))
+                    return skill;
+            }
+            catch {
+                // Fallback: keyword matching — split on common separators, strip non-word chars
+                const keywords = skill.trigger.split(/[\s,;|]+/).map(k => k.replace(/[^\w-]/g, '').toLowerCase()).filter(k => k.length > 2);
+                const lower = message.toLowerCase();
+                if (keywords.some((kw) => lower.includes(kw)))
+                    return skill;
+            }
+        }
+        return null;
+    }
+    async improveSkill(skill, conversation, provider) {
+        const conversationText = conversation
+            .map((m) => `${m.role}: ${m.content}`)
+            .join('\n');
+        const prompt = SKILL_IMPROVEMENT_PROMPT +
+            skillToMarkdown(skill) +
+            '\n\nConversation where it was used:\n' +
+            conversationText +
+            SKILL_IMPROVEMENT_SUFFIX;
+        try {
+            const response = await provider.chat([{ id: 'improve', role: 'user', content: prompt, timestamp: Date.now() }], 'You are a skill improvement assistant. Respond only with valid JSON.');
+            const json = extractJson(response);
+            if (!json || !json.shouldImprove || !json.improvements)
+                return;
+            const { improvements } = json;
+            if (improvements.instructions)
+                skill.instructions = improvements.instructions;
+            if (improvements.trigger)
+                skill.trigger = improvements.trigger;
+            if (improvements.examples)
+                skill.examples = [...skill.examples, ...improvements.examples];
+            skill.version++;
+            await this.saveSkill(skill);
+        }
+        catch {
+            // Silently fail — improvement is best-effort
+        }
+    }
+    getSkills() {
+        return [...this.skills];
+    }
+}
+exports.SkillLearner = SkillLearner;
+// ─── Helpers ────────────────────────────────────────────────
+function extractJson(text) {
+    // Try to extract JSON from response (may be wrapped in markdown code block)
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[0]);
+    }
+    catch {
+        return null;
+    }
+}
+function skillToMarkdown(skill) {
+    const lines = [
+        `# Skill: ${skill.name}`,
+        '',
+        '## Description',
+        skill.description,
+        '',
+        '## Trigger',
+        `Pattern: ${skill.trigger}`,
+        '',
+        '## Instructions',
+        skill.instructions,
+        '',
+        '## Examples',
+        ...skill.examples.map((e) => `- "${e}"`),
+        '',
+        '## Metadata',
+        `- Created: ${skill.createdAt.toISOString()}`,
+        `- Version: ${skill.version}`,
+        `- Usage Count: ${skill.usageCount}`,
+        `- Last Used: ${skill.lastUsed?.toISOString() ?? 'never'}`,
+        '',
+    ];
+    return lines.join('\n');
+}
+function parseSkillMarkdown(content) {
+    const nameMatch = content.match(/^# Skill:\s*(.+)$/m);
+    if (!nameMatch)
+        return null;
+    const section = (heading) => {
+        const re = new RegExp(`## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+        const m = content.match(re);
+        return m ? m[1].trim() : '';
+    };
+    const description = section('Description');
+    const triggerLine = section('Trigger');
+    const trigger = triggerLine.replace(/^Pattern:\s*/i, '').trim();
+    const instructions = section('Instructions');
+    const examplesRaw = section('Examples');
+    const examples = examplesRaw
+        .split('\n')
+        .map((l) => l.replace(/^-\s*"?|"?\s*$/g, '').trim())
+        .filter(Boolean);
+    const metadata = section('Metadata');
+    const getMeta = (key) => {
+        const m = metadata.match(new RegExp(`- ${key}:\\s*(.+)`, 'i'));
+        return m ? m[1].trim() : '';
+    };
+    return {
+        name: nameMatch[1].trim(),
+        description,
+        trigger,
+        instructions,
+        examples,
+        createdAt: new Date(getMeta('Created') || Date.now()),
+        version: parseInt(getMeta('Version') || '1', 10),
+        usageCount: parseInt(getMeta('Usage Count') || '0', 10),
+        lastUsed: getMeta('Last Used') !== 'never' ? new Date(getMeta('Last Used')) : undefined,
+    };
+}
+//# sourceMappingURL=auto-learn.js.map

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