opc-agent 2.0.2 → 3.0.0

package/dist/mcp/servers/json-mcp.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonServer = createJsonServer;
+function jsonPathQuery(obj, path) {
+    const parts = path.replace(/^\$\.?/, '').split('.');
+    let current = [obj];
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const next = [];
+        for (const item of current) {
+            if (part === '*') {
+                if (Array.isArray(item))
+                    next.push(...item);
+                else if (typeof item === 'object' && item)
+                    next.push(...Object.values(item));
+            }
+            else if (part.match(/^\[(\d+)\]$/)) {
+                const idx = parseInt(part.slice(1, -1));
+                if (Array.isArray(item) && item[idx] !== undefined)
+                    next.push(item[idx]);
+            }
+            else {
+                if (item && typeof item === 'object' && part in item)
+                    next.push(item[part]);
+            }
+        }
+        current = next;
+    }
+    return current;
+}
+function createJsonServer() {
+    return {
+        name: 'json',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'json_query',
+                description: 'Query JSON data using dot-notation path (e.g. "users.0.name", "items.*")',
+                inputSchema: { type: 'object', properties: { data: { description: 'JSON string or object' }, path: { type: 'string', description: 'Dot-notation path' } }, required: ['data', 'path'] },
+                handler: async (args) => {
+                    const obj = typeof args.data === 'string' ? JSON.parse(args.data) : args.data;
+                    return { results: jsonPathQuery(obj, args.path) };
+                },
+            },
+            {
+                name: 'json_transform',
+                description: 'Transform JSON: pick fields, rename keys, flatten',
+                inputSchema: { type: 'object', properties: { data: {}, operation: { type: 'string', enum: ['pick', 'omit', 'flatten', 'keys', 'values'] }, fields: { type: 'array', items: { type: 'string' } } }, required: ['data', 'operation'] },
+                handler: async (args) => {
+                    const obj = typeof args.data === 'string' ? JSON.parse(args.data) : args.data;
+                    switch (args.operation) {
+                        case 'pick': {
+                            const result = {};
+                            for (const f of args.fields || [])
+                                if (f in obj)
+                                    result[f] = obj[f];
+                            return { result };
+                        }
+                        case 'omit': {
+                            const result = { ...obj };
+                            for (const f of args.fields || [])
+                                delete result[f];
+                            return { result };
+                        }
+                        case 'flatten': {
+                            const result = {};
+                            const recurse = (o, prefix) => {
+                                for (const [k, v] of Object.entries(o)) {
+                                    const key = prefix ? `${prefix}.${k}` : k;
+                                    if (v && typeof v === 'object' && !Array.isArray(v))
+                                        recurse(v, key);
+                                    else
+                                        result[key] = v;
+                                }
+                            };
+                            recurse(obj, '');
+                            return { result };
+                        }
+                        case 'keys': return { result: Object.keys(obj) };
+                        case 'values': return { result: Object.values(obj) };
+                        default: throw new Error(`Unknown operation: ${args.operation}`);
+                    }
+                },
+            },
+            {
+                name: 'json_validate',
+                description: 'Check if a string is valid JSON',
+                inputSchema: { type: 'object', properties: { data: { type: 'string' } }, required: ['data'] },
+                handler: async (args) => {
+                    try {
+                        JSON.parse(args.data);
+                        return { valid: true };
+                    }
+                    catch (e) {
+                        return { valid: false, error: e.message };
+                    }
+                },
+            },
+            {
+                name: 'json_diff',
+                description: 'Compare two JSON objects and return differences',
+                inputSchema: { type: 'object', properties: { a: {}, b: {} }, required: ['a', 'b'] },
+                handler: async (args) => {
+                    const a = typeof args.a === 'string' ? JSON.parse(args.a) : args.a;
+                    const b = typeof args.b === 'string' ? JSON.parse(args.b) : args.b;
+                    const diffs = [];
+                    const compare = (x, y, path) => {
+                        if (x === y)
+                            return;
+                        if (typeof x !== typeof y || typeof x !== 'object' || !x || !y) {
+                            diffs.push({ path, a: x, b: y });
+                            return;
+                        }
+                        const keys = new Set([...Object.keys(x), ...Object.keys(y)]);
+                        for (const k of keys)
+                            compare(x[k], y[k], path ? `${path}.${k}` : k);
+                    };
+                    compare(a, b, '');
+                    return { equal: diffs.length === 0, differences: diffs };
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=json-mcp.js.map

package/dist/mcp/servers/memory-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createMemoryServer(): MCPServerConfig;
+//# sourceMappingURL=memory-mcp.d.ts.map

package/dist/mcp/servers/memory-mcp.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryServer = createMemoryServer;
+function createMemoryServer() {
+    const store = new Map();
+    return {
+        name: 'memory',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'memory_store',
+                description: 'Store a key-value pair in memory with optional tags',
+                inputSchema: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'any' }, tags: { type: 'array', items: { type: 'string' } } }, required: ['key', 'value'] },
+                handler: async (args) => {
+                    const now = new Date().toISOString();
+                    const existing = store.get(args.key);
+                    store.set(args.key, { value: args.value, tags: args.tags || [], created: existing?.created || now, updated: now });
+                    return { stored: args.key };
+                },
+            },
+            {
+                name: 'memory_recall',
+                description: 'Recall a value by key',
+                inputSchema: { type: 'object', properties: { key: { type: 'string' } }, required: ['key'] },
+                handler: async (args) => {
+                    const entry = store.get(args.key);
+                    if (!entry)
+                        return { found: false };
+                    return { found: true, ...entry };
+                },
+            },
+            {
+                name: 'memory_search',
+                description: 'Search memory entries by tag or substring in key',
+                inputSchema: { type: 'object', properties: { query: { type: 'string' }, tag: { type: 'string' } }, required: [] },
+                handler: async (args) => {
+                    let results = Array.from(store.entries()).map(([k, v]) => ({ key: k, ...v }));
+                    if (args.tag)
+                        results = results.filter(r => r.tags.includes(args.tag));
+                    if (args.query)
+                        results = results.filter(r => r.key.includes(args.query) || JSON.stringify(r.value).includes(args.query));
+                    return { results, count: results.length };
+                },
+            },
+            {
+                name: 'memory_delete',
+                description: 'Delete a memory entry',
+                inputSchema: { type: 'object', properties: { key: { type: 'string' } }, required: ['key'] },
+                handler: async (args) => ({ deleted: store.delete(args.key) }),
+            },
+            {
+                name: 'memory_list',
+                description: 'List all memory keys',
+                inputSchema: { type: 'object', properties: {} },
+                handler: async () => ({ keys: Array.from(store.keys()), count: store.size }),
+            },
+        ],
+    };
+}
+//# sourceMappingURL=memory-mcp.js.map

package/dist/mcp/servers/regex-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createRegexServer(): MCPServerConfig;
+//# sourceMappingURL=regex-mcp.d.ts.map

package/dist/mcp/servers/regex-mcp.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegexServer = createRegexServer;
+function createRegexServer() {
+    return {
+        name: 'regex',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'regex_test',
+                description: 'Test if a string matches a regex pattern',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, flags: { type: 'string', default: '' }, text: { type: 'string' } }, required: ['pattern', 'text'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern, args.flags || '');
+                    return { matches: re.test(args.text), pattern: args.pattern };
+                },
+            },
+            {
+                name: 'regex_match',
+                description: 'Find all matches of a regex in text',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, flags: { type: 'string', default: 'g' }, text: { type: 'string' } }, required: ['pattern', 'text'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern, args.flags || 'g');
+                    const matches = [];
+                    let m;
+                    while ((m = re.exec(args.text)) !== null) {
+                        matches.push({ match: m[0], index: m.index, groups: m.groups });
+                        if (!re.global)
+                            break;
+                    }
+                    return { matches, count: matches.length };
+                },
+            },
+            {
+                name: 'regex_replace',
+                description: 'Replace matches in text using regex',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, flags: { type: 'string', default: 'g' }, text: { type: 'string' }, replacement: { type: 'string' } }, required: ['pattern', 'text', 'replacement'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern, args.flags || 'g');
+                    return { result: args.text.replace(re, args.replacement) };
+                },
+            },
+            {
+                name: 'regex_split',
+                description: 'Split text by regex pattern',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, text: { type: 'string' }, limit: { type: 'number' } }, required: ['pattern', 'text'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern);
+                    const parts = args.text.split(re, args.limit);
+                    return { parts, count: parts.length };
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=regex-mcp.js.map

package/dist/mcp/servers/web-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createWebServer(): MCPServerConfig;
+//# sourceMappingURL=web-mcp.d.ts.map

package/dist/mcp/servers/web-mcp.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebServer = createWebServer;
+function createWebServer() {
+    return {
+        name: 'web',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'web_fetch',
+                description: 'Fetch a URL and return its content',
+                inputSchema: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', default: 'GET' }, headers: { type: 'object' }, body: { type: 'string' } }, required: ['url'] },
+                handler: async (args) => {
+                    const res = await fetch(args.url, { method: args.method || 'GET', headers: args.headers, body: args.body });
+                    const contentType = res.headers.get('content-type') || '';
+                    const text = await res.text();
+                    return { status: res.status, contentType, body: text.slice(0, 50000), truncated: text.length > 50000 };
+                },
+            },
+            {
+                name: 'web_extract_text',
+                description: 'Fetch a URL and extract readable text (strips HTML tags)',
+                inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+                handler: async (args) => {
+                    const res = await fetch(args.url);
+                    const html = await res.text();
+                    const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+                    return { text: text.slice(0, 30000), truncated: text.length > 30000 };
+                },
+            },
+            {
+                name: 'web_search',
+                description: 'Search the web (simulated — returns search URL for manual use)',
+                inputSchema: { type: 'object', properties: { query: { type: 'string' }, engine: { type: 'string', enum: ['google', 'bing', 'duckduckgo'], default: 'duckduckgo' } }, required: ['query'] },
+                handler: async (args) => {
+                    const engines = {
+                        google: `https://www.google.com/search?q=${encodeURIComponent(args.query)}`,
+                        bing: `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`,
+                        duckduckgo: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`,
+                    };
+                    const url = engines[args.engine || 'duckduckgo'];
+                    const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0 opc-mcp/1.0' } });
+                    const html = await res.text();
+                    const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+                    return { query: args.query, engine: args.engine || 'duckduckgo', results: text.slice(0, 20000) };
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=web-mcp.js.map

package/dist/memory/index.d.ts

@@ -1,4 +1,6 @@
 import type { Message, MemoryStore } from '../core/types';
+export { BrainSeedLoader, KnowledgeEvolver } from './seed-loader';
+export type { BrainSeedConfig, SeedPage, SeedResult, PromotionResult, PromotionCandidate } from './seed-loader';
 export declare class InMemoryStore implements MemoryStore {
     private store;
     private conversations;

package/dist/memory/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryStore = void 0;
+exports.InMemoryStore = exports.KnowledgeEvolver = exports.BrainSeedLoader = void 0;
+var seed_loader_1 = require("./seed-loader");
+Object.defineProperty(exports, "BrainSeedLoader", { enumerable: true, get: function () { return seed_loader_1.BrainSeedLoader; } });
+Object.defineProperty(exports, "KnowledgeEvolver", { enumerable: true, get: function () { return seed_loader_1.KnowledgeEvolver; } });
 class InMemoryStore {
     store = new Map();
     conversations = new Map();

package/dist/memory/seed-loader.d.ts

@@ -0,0 +1,51 @@
+export interface BrainSeedConfig {
+    seeds: string[];
+    autoSeed: boolean;
+    seedMarkerFile?: string;
+    evolve?: {
+        enabled: boolean;
+        direction: 'bottom-up' | 'top-down';
+    };
+}
+export interface SeedPage {
+    slug: string;
+    content: string;
+    tier: string;
+}
+export interface SeedResult {
+    imported: number;
+    pages: string[];
+}
+export interface PromotionCandidate {
+    slug: string;
+    content: string;
+    fromTier: string;
+    toTier: string;
+    confidence: number;
+}
+export interface PromotionResult {
+    candidates: PromotionCandidate[];
+    promoted: number;
+}
+export declare class BrainSeedLoader {
+    private agentDir;
+    private config;
+    private markerFile;
+    constructor(agentDir: string, config: BrainSeedConfig);
+    isSeeded(): Promise<boolean>;
+    seedBrain(brain: any): Promise<SeedResult>;
+    markSeeded(): Promise<void>;
+    parseSeedFile(filePath: string, tier: string): SeedPage[];
+    private inferTier;
+    private slugify;
+}
+export declare class KnowledgeEvolver {
+    private tierOrder;
+    checkPromotion(brain: any, options?: {
+        minInteractions?: number;
+        confidenceThreshold?: number;
+    }): Promise<PromotionResult>;
+    promoteToJob(brain: any, knowledge: string, jobSlug: string): Promise<void>;
+    promoteToIndustry(brain: any, knowledge: string, industrySlug: string): Promise<void>;
+}
+//# sourceMappingURL=seed-loader.d.ts.map

package/dist/memory/seed-loader.js

@@ -0,0 +1,200 @@
+"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.KnowledgeEvolver = exports.BrainSeedLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class BrainSeedLoader {
+    agentDir;
+    config;
+    markerFile;
+    constructor(agentDir, config) {
+        this.agentDir = agentDir;
+        this.config = config;
+        this.markerFile = config.seedMarkerFile
+            ? path.resolve(agentDir, config.seedMarkerFile)
+            : path.resolve(agentDir, '.brain-seeded');
+    }
+    async isSeeded() {
+        return fs.existsSync(this.markerFile);
+    }
+    async seedBrain(brain) {
+        const allPages = [];
+        for (const seedPath of this.config.seeds) {
+            const fullPath = path.resolve(this.agentDir, seedPath);
+            if (!fs.existsSync(fullPath))
+                continue;
+            const tier = this.inferTier(seedPath);
+            const pages = this.parseSeedFile(fullPath, tier);
+            allPages.push(...pages);
+        }
+        const importedSlugs = [];
+        for (const page of allPages) {
+            if (brain && typeof brain.store === 'function') {
+                await brain.store('brain-seeds', page.slug, page.content, {
+                    tier: page.tier,
+                    source: 'brain-seed',
+                });
+            }
+            else if (brain && typeof brain.learn === 'function') {
+                await brain.learn(page.content, {
+                    tags: ['brain-seed', page.tier],
+                    slug: page.slug,
+                });
+            }
+            importedSlugs.push(page.slug);
+        }
+        return { imported: importedSlugs.length, pages: importedSlugs };
+    }
+    async markSeeded() {
+        const dir = path.dirname(this.markerFile);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.markerFile, JSON.stringify({
+            seededAt: new Date().toISOString(),
+            seeds: this.config.seeds,
+        }, null, 2));
+    }
+    parseSeedFile(filePath, tier) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const pages = [];
+        const sections = content.split(/^## /m);
+        for (const section of sections) {
+            const trimmed = section.trim();
+            if (!trimmed)
+                continue;
+            const newlineIdx = trimmed.indexOf('\n');
+            if (newlineIdx === -1 && sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
+                // This is preamble before any ## heading — skip or treat as intro
+                continue;
+            }
+            let title;
+            let body;
+            if (sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
+                // Preamble (before first ##)
+                continue;
+            }
+            if (newlineIdx === -1) {
+                title = trimmed;
+                body = '';
+            }
+            else {
+                title = trimmed.slice(0, newlineIdx).trim();
+                body = trimmed.slice(newlineIdx + 1).trim();
+            }
+            const slug = `seed/${tier}/${this.slugify(title)}`;
+            pages.push({ slug, content: `## ${title}\n\n${body}`, tier });
+        }
+        return pages;
+    }
+    inferTier(seedPath) {
+        const basename = path.basename(seedPath, path.extname(seedPath)).toLowerCase();
+        if (basename.includes('industry'))
+            return 'industry';
+        if (basename.includes('job'))
+            return 'job';
+        if (basename.includes('workstation'))
+            return 'workstation';
+        return 'workstation';
+    }
+    slugify(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+}
+exports.BrainSeedLoader = BrainSeedLoader;
+class KnowledgeEvolver {
+    tierOrder = ['workstation', 'job', 'industry'];
+    async checkPromotion(brain, options = {}) {
+        const minInteractions = options.minInteractions ?? 50;
+        const confidenceThreshold = options.confidenceThreshold ?? 0.8;
+        const result = { candidates: [], promoted: 0 };
+        // Search for frequently referenced seed knowledge
+        if (!brain || typeof brain.search !== 'function')
+            return result;
+        try {
+            const seedPages = await brain.search('brain-seeds', 'seed/', 100);
+            if (!Array.isArray(seedPages))
+                return result;
+            for (const page of seedPages) {
+                const meta = page.metadata || {};
+                const usageCount = meta.usageCount ?? 0;
+                const tier = meta.tier || 'workstation';
+                if (usageCount < minInteractions)
+                    continue;
+                const confidence = Math.min(usageCount / (minInteractions * 2), 1.0);
+                if (confidence < confidenceThreshold)
+                    continue;
+                const tierIdx = this.tierOrder.indexOf(tier);
+                if (tierIdx <= 0)
+                    continue; // already at highest tier or unknown
+                const toTier = this.tierOrder[tierIdx - 1];
+                result.candidates.push({
+                    slug: page.id || page.slug,
+                    content: page.content,
+                    fromTier: tier,
+                    toTier,
+                    confidence,
+                });
+            }
+        }
+        catch {
+            // Silent fail
+        }
+        return result;
+    }
+    async promoteToJob(brain, knowledge, jobSlug) {
+        if (brain && typeof brain.store === 'function') {
+            await brain.store('brain-seeds', jobSlug, knowledge, {
+                tier: 'job',
+                source: 'promotion',
+                promotedAt: new Date().toISOString(),
+            });
+        }
+    }
+    async promoteToIndustry(brain, knowledge, industrySlug) {
+        if (brain && typeof brain.store === 'function') {
+            await brain.store('brain-seeds', industrySlug, knowledge, {
+                tier: 'industry',
+                source: 'promotion',
+                promotedAt: new Date().toISOString(),
+            });
+        }
+    }
+}
+exports.KnowledgeEvolver = KnowledgeEvolver;
+//# sourceMappingURL=seed-loader.js.map