opc-agent 3.0.1 → 4.0.1

package/dist/core/context-refs.js

@@ -0,0 +1,162 @@
+"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.ContextRefResolver = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const MAX_CONTENT_LENGTH = 5000;
+function truncate(text, max = MAX_CONTENT_LENGTH) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + `\n...[truncated, ${text.length - max} chars omitted]`;
+}
+class ContextRefResolver {
+    /**
+     * Parse @-references from text without resolving content.
+     */
+    parseRefs(text) {
+        const refs = [];
+        const patterns = [
+            [/@file:(\S+)/g, 'file', (m) => m[1]],
+            [/@folder:(\S+)/g, 'folder', (m) => m[1]],
+            [/@url:(https?:\/\/\S+)/g, 'url', (m) => m[1]],
+            [/@git-diff\b/g, 'git-diff', () => 'git-diff'],
+            [/@git-log:(\d+)/g, 'git-log', (m) => m[1]],
+            [/@git-log\b(?!:)/g, 'git-log', () => '10'],
+        ];
+        for (const [regex, type, extract] of patterns) {
+            let match;
+            while ((match = regex.exec(text)) !== null) {
+                refs.push({ type, path: extract(match) });
+            }
+        }
+        return refs;
+    }
+    /**
+     * Resolve content for each ref. Returns new array with content filled in.
+     */
+    async resolveRefs(refs) {
+        return Promise.all(refs.map(async (ref) => {
+            try {
+                const content = await this.resolveOne(ref);
+                return { ...ref, content: truncate(content) };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { ...ref, content: `[Error resolving @${ref.type}:${ref.path}]: ${msg}` };
+            }
+        }));
+    }
+    async resolveOne(ref) {
+        switch (ref.type) {
+            case 'file':
+                return fs.readFileSync(ref.path, 'utf-8');
+            case 'folder':
+                return this.listDir(ref.path);
+            case 'url':
+                return await this.fetchUrl(ref.path);
+            case 'git-diff':
+                return (0, child_process_1.execSync)('git diff', { encoding: 'utf-8', timeout: 10000 });
+            case 'git-log': {
+                const n = parseInt(ref.path) || 10;
+                return (0, child_process_1.execSync)(`git log --oneline -${n}`, { encoding: 'utf-8', timeout: 10000 });
+            }
+            default:
+                return `[Unknown ref type: ${ref.type}]`;
+        }
+    }
+    listDir(dirPath, prefix = '', depth = 0) {
+        if (depth > 5)
+            return prefix + '...(max depth)\n';
+        if (!fs.existsSync(dirPath))
+            throw new Error(`Directory not found: ${dirPath}`);
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        let result = '';
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            result += `${prefix}${entry.isDirectory() ? '📁 ' : '📄 '}${entry.name}\n`;
+            if (entry.isDirectory()) {
+                result += this.listDir(path.join(dirPath, entry.name), prefix + '  ', depth + 1);
+            }
+        }
+        return result;
+    }
+    async fetchUrl(url) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10000);
+        try {
+            const res = await fetch(url, { signal: controller.signal });
+            const text = await res.text();
+            return text;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    /**
+     * Inject resolved refs as system messages before the user's last message.
+     */
+    injectRefs(messages, refs) {
+        if (refs.length === 0)
+            return messages;
+        const resolvedRefs = refs.filter(r => r.content);
+        if (resolvedRefs.length === 0)
+            return messages;
+        const contextMessages = resolvedRefs.map(ref => ({
+            role: 'system',
+            content: `[Context from @${ref.type}:${ref.path}]\n\`\`\`\n${ref.content}\n\`\`\``,
+        }));
+        // Insert before the last user message
+        const result = [...messages];
+        let lastUserIdx = -1;
+        for (let i = result.length - 1; i >= 0; i--) {
+            if (result[i].role === 'user') {
+                lastUserIdx = i;
+                break;
+            }
+        }
+        if (lastUserIdx >= 0) {
+            result.splice(lastUserIdx, 0, ...contextMessages);
+        }
+        else {
+            result.push(...contextMessages);
+        }
+        return result;
+    }
+}
+exports.ContextRefResolver = ContextRefResolver;
+//# sourceMappingURL=context-refs.js.map

package/dist/core/gateway.d.ts

@@ -0,0 +1,53 @@
+import { EventEmitter } from 'events';
+export interface AgentConfig {
+    id: string;
+    name: string;
+    model?: string;
+    skills?: string[];
+}
+export interface ChannelConfig {
+    id: string;
+    type: string;
+    config?: Record<string, unknown>;
+}
+export interface GatewayConfig {
+    port: number;
+    agents: AgentConfig[];
+    channels: ChannelConfig[];
+}
+interface GatewayMessage {
+    id: string;
+    content: string;
+    channel: string;
+    timestamp: number;
+}
+export declare class Gateway extends EventEmitter {
+    private config;
+    private agents;
+    private channels;
+    private running;
+    private startTime;
+    private messagesProcessed;
+    private latencies;
+    private errors;
+    constructor(config: GatewayConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    routeMessage(message: GatewayMessage, channel: string): Promise<string>;
+    addAgent(config: AgentConfig): void;
+    removeAgent(id: string): void;
+    addChannel(config: ChannelConfig): void;
+    getStatus(): {
+        uptime: number;
+        agents: number;
+        channels: number;
+        messagesProcessed: number;
+    };
+    getMetrics(): {
+        messagesPerMinute: number;
+        avgLatency: number;
+        errorRate: number;
+    };
+}
+export {};
+//# sourceMappingURL=gateway.d.ts.map

package/dist/core/gateway.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gateway = void 0;
+const events_1 = require("events");
+class Gateway extends events_1.EventEmitter {
+    config;
+    agents = new Map();
+    channels = new Map();
+    running = false;
+    startTime = 0;
+    messagesProcessed = 0;
+    latencies = [];
+    errors = 0;
+    constructor(config) {
+        super();
+        this.config = config;
+        for (const a of config.agents)
+            this.agents.set(a.id, a);
+        for (const c of config.channels)
+            this.channels.set(c.id, c);
+    }
+    async start() {
+        if (this.running)
+            throw new Error('Gateway already running');
+        this.running = true;
+        this.startTime = Date.now();
+        this.emit('started');
+    }
+    async stop() {
+        if (!this.running)
+            throw new Error('Gateway not running');
+        this.running = false;
+        this.emit('stopped');
+    }
+    async routeMessage(message, channel) {
+        if (!this.running)
+            throw new Error('Gateway not running');
+        const start = Date.now();
+        this.messagesProcessed++;
+        // Simple round-robin routing
+        const agentIds = Array.from(this.agents.keys());
+        if (agentIds.length === 0) {
+            this.errors++;
+            throw new Error('No agents available');
+        }
+        const agentId = agentIds[this.messagesProcessed % agentIds.length];
+        this.latencies.push(Date.now() - start);
+        return agentId;
+    }
+    addAgent(config) {
+        this.agents.set(config.id, config);
+    }
+    removeAgent(id) {
+        if (!this.agents.has(id))
+            throw new Error(`Agent ${id} not found`);
+        this.agents.delete(id);
+    }
+    addChannel(config) {
+        this.channels.set(config.id, config);
+    }
+    getStatus() {
+        return {
+            uptime: this.running ? Date.now() - this.startTime : 0,
+            agents: this.agents.size,
+            channels: this.channels.size,
+            messagesProcessed: this.messagesProcessed,
+        };
+    }
+    getMetrics() {
+        const upMinutes = this.running ? (Date.now() - this.startTime) / 60000 : 1;
+        const avgLatency = this.latencies.length ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length : 0;
+        return {
+            messagesPerMinute: this.messagesProcessed / Math.max(upMinutes, 0.001),
+            avgLatency,
+            errorRate: this.messagesProcessed ? this.errors / this.messagesProcessed : 0,
+        };
+    }
+}
+exports.Gateway = Gateway;
+//# sourceMappingURL=gateway.js.map

package/dist/core/heartbeat.d.ts

@@ -0,0 +1,19 @@
+export interface HeartbeatConfig {
+    interval: number;
+    checkFn: () => Promise<string>;
+}
+export declare class HeartbeatManager {
+    private config;
+    private timer;
+    private callbacks;
+    private lastBeat;
+    constructor(config: HeartbeatConfig);
+    start(): void;
+    stop(): void;
+    onBeat(callback: (status: string) => void): void;
+    getLastBeat(): {
+        timestamp: number;
+        status: string;
+    } | null;
+}
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/core/heartbeat.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatManager = void 0;
+class HeartbeatManager {
+    config;
+    timer = null;
+    callbacks = [];
+    lastBeat = null;
+    constructor(config) {
+        if (!config.interval || config.interval < 100) {
+            throw new Error('HeartbeatManager requires interval >= 100ms');
+        }
+        if (typeof config.checkFn !== 'function') {
+            throw new Error('HeartbeatManager requires checkFn');
+        }
+        this.config = config;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(async () => {
+            try {
+                const status = await this.config.checkFn();
+                this.lastBeat = { timestamp: Date.now(), status };
+                for (const cb of this.callbacks)
+                    cb(status);
+            }
+            catch (err) {
+                const status = `error: ${err.message}`;
+                this.lastBeat = { timestamp: Date.now(), status };
+                for (const cb of this.callbacks)
+                    cb(status);
+            }
+        }, this.config.interval);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    onBeat(callback) {
+        this.callbacks.push(callback);
+    }
+    getLastBeat() {
+        return this.lastBeat;
+    }
+}
+exports.HeartbeatManager = HeartbeatManager;
+//# sourceMappingURL=heartbeat.js.map

package/dist/core/hooks.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hooks Module - v1.0.0
+ * Event hook system with priority ordering and context modification.
+ */
+export type HookEvent = 'before:message' | 'after:message' | 'before:tool' | 'after:tool' | 'before:llm' | 'after:llm' | 'before:send' | 'after:send' | 'before:learn' | 'after:learn' | 'before:recall' | 'after:recall' | 'on:error' | 'on:start' | 'on:stop';
+export declare const ALL_HOOK_EVENTS: HookEvent[];
+export interface HookContext {
+    [key: string]: unknown;
+}
+export type HookHandler = (ctx: HookContext) => HookContext | void | Promise<HookContext | void>;
+export declare class HookManager {
+    private hooks;
+    register(event: HookEvent, handler: HookHandler, options?: {
+        priority?: number;
+        name?: string;
+    }): string;
+    unregister(id: string): boolean;
+    run(event: HookEvent, ctx?: HookContext): Promise<HookContext>;
+    getRegistered(event?: HookEvent): {
+        id: string;
+        event: HookEvent;
+        priority: number;
+        name?: string;
+    }[];
+    clear(event?: HookEvent): void;
+    hasHooks(event: HookEvent): boolean;
+}
+//# sourceMappingURL=hooks.d.ts.map

package/dist/core/hooks.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Hooks Module - v1.0.0
+ * Event hook system with priority ordering and context modification.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookManager = exports.ALL_HOOK_EVENTS = void 0;
+exports.ALL_HOOK_EVENTS = [
+    'before:message', 'after:message',
+    'before:tool', 'after:tool',
+    'before:llm', 'after:llm',
+    'before:send', 'after:send',
+    'before:learn', 'after:learn',
+    'before:recall', 'after:recall',
+    'on:error', 'on:start', 'on:stop',
+];
+let hookIdCounter = 0;
+class HookManager {
+    hooks = new Map();
+    register(event, handler, options) {
+        const id = `hook_${++hookIdCounter}`;
+        const entry = {
+            id,
+            event,
+            handler,
+            priority: options?.priority ?? 100,
+            name: options?.name,
+        };
+        if (!this.hooks.has(event))
+            this.hooks.set(event, []);
+        const list = this.hooks.get(event);
+        list.push(entry);
+        list.sort((a, b) => a.priority - b.priority);
+        return id;
+    }
+    unregister(id) {
+        for (const [event, list] of this.hooks) {
+            const idx = list.findIndex(h => h.id === id);
+            if (idx !== -1) {
+                list.splice(idx, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    async run(event, ctx = {}) {
+        const list = this.hooks.get(event);
+        if (!list || list.length === 0)
+            return ctx;
+        let current = { ...ctx };
+        for (const hook of list) {
+            const result = await hook.handler(current);
+            if (result)
+                current = { ...current, ...result };
+        }
+        return current;
+    }
+    getRegistered(event) {
+        const results = [];
+        const events = event ? [event] : exports.ALL_HOOK_EVENTS;
+        for (const e of events) {
+            const list = this.hooks.get(e) ?? [];
+            for (const h of list) {
+                results.push({ id: h.id, event: h.event, priority: h.priority, name: h.name });
+            }
+        }
+        return results;
+    }
+    clear(event) {
+        if (event) {
+            this.hooks.delete(event);
+        }
+        else {
+            this.hooks.clear();
+        }
+    }
+    hasHooks(event) {
+        return (this.hooks.get(event)?.length ?? 0) > 0;
+    }
+}
+exports.HookManager = HookManager;
+//# sourceMappingURL=hooks.js.map

package/dist/core/ide-bridge.d.ts

@@ -0,0 +1,53 @@
+export interface IDEConfig {
+    editor: 'vscode' | 'jetbrains' | 'zed' | 'cursor';
+    workspacePath?: string;
+}
+export interface Diagnostic {
+    path: string;
+    line: number;
+    column: number;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+}
+export interface TextEdit {
+    range: Range;
+    newText: string;
+}
+export interface Range {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export interface SearchOptions {
+    caseSensitive?: boolean;
+    regex?: boolean;
+    include?: string;
+    exclude?: string;
+    maxResults?: number;
+}
+export interface SearchResult {
+    path: string;
+    line: number;
+    column: number;
+    text: string;
+}
+export declare class IDEBridge {
+    private config;
+    constructor(config: IDEConfig);
+    private getCliCommand;
+    private exec;
+    openFile(path: string, line?: number): Promise<void>;
+    getDiagnostics(path?: string): Promise<Diagnostic[]>;
+    runCommand(command: string): Promise<string>;
+    getOpenFiles(): Promise<string[]>;
+    applyEdit(path: string, edits: TextEdit[]): Promise<void>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    getSelection(): Promise<{
+        path: string;
+        text: string;
+        range: Range;
+    } | null>;
+    installExtension(extensionId: string): Promise<void>;
+}
+//# sourceMappingURL=ide-bridge.d.ts.map

package/dist/core/ide-bridge.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDEBridge = void 0;
+const child_process_1 = require("child_process");
+class IDEBridge {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getCliCommand() {
+        switch (this.config.editor) {
+            case 'vscode':
+            case 'cursor': return this.config.editor === 'cursor' ? 'cursor' : 'code';
+            case 'jetbrains': return 'idea';
+            case 'zed': return 'zed';
+        }
+    }
+    exec(cmd) {
+        try {
+            return (0, child_process_1.execSync)(cmd, { encoding: 'utf-8', timeout: 10000, cwd: this.config.workspacePath }).trim();
+        }
+        catch (e) {
+            throw new Error(`IDE command failed: ${e.message}`);
+        }
+    }
+    async openFile(path, line) {
+        const cli = this.getCliCommand();
+        const target = line ? `${path}:${line}` : path;
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            this.exec(`${cli} --goto "${target}"`);
+        }
+        else if (this.config.editor === 'zed') {
+            this.exec(`zed "${target}"`);
+        }
+        else {
+            this.exec(`${cli} --line ${line || 1} "${path}"`);
+        }
+    }
+    async getDiagnostics(path) {
+        // VS Code doesn't expose diagnostics via CLI; return empty as stub
+        return [];
+    }
+    async runCommand(command) {
+        const cli = this.getCliCommand();
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            return this.exec(`${cli} --command "${command}"`);
+        }
+        throw new Error(`runCommand not supported for ${this.config.editor}`);
+    }
+    async getOpenFiles() {
+        // Stub — no standard CLI to get open files
+        return [];
+    }
+    async applyEdit(path, edits) {
+        // Stub — would use editor's API/extension
+        if (edits.length === 0)
+            return;
+        throw new Error('applyEdit requires an IDE extension to be installed. Use file system edits as fallback.');
+    }
+    async search(query, options) {
+        const cli = this.getCliCommand();
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            try {
+                const args = [`--search "${query}"`];
+                if (options?.include)
+                    args.push(`--include "${options.include}"`);
+                const output = this.exec(`${cli} ${args.join(' ')}`);
+                // Parse output lines
+                return output.split('\n').filter(Boolean).map(line => {
+                    const match = line.match(/^(.+):(\d+):(\d+):(.*)$/);
+                    if (!match)
+                        return { path: '', line: 0, column: 0, text: line };
+                    return { path: match[1], line: parseInt(match[2]), column: parseInt(match[3]), text: match[4] };
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    }
+    async getSelection() {
+        // Stub — requires editor extension
+        return null;
+    }
+    async installExtension(extensionId) {
+        const cli = this.getCliCommand();
+        if (this.config.editor === 'vscode' || this.config.editor === 'cursor') {
+            this.exec(`${cli} --install-extension ${extensionId}`);
+        }
+        else {
+            throw new Error(`installExtension not supported for ${this.config.editor}`);
+        }
+    }
+}
+exports.IDEBridge = IDEBridge;
+//# sourceMappingURL=ide-bridge.js.map

package/dist/core/node-network.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from 'events';
+export interface RemoteNode {
+    id: string;
+    name: string;
+    host: string;
+    port: number;
+    type: 'vps' | 'pi' | 'phone' | 'desktop';
+    status: 'online' | 'offline' | 'pairing';
+    capabilities: string[];
+    lastSeen: number;
+}
+export declare class NodeNetwork extends EventEmitter {
+    private nodes;
+    addNode(config: Partial<RemoteNode>): RemoteNode;
+    removeNode(id: string): void;
+    listNodes(): RemoteNode[];
+    getNode(id: string): RemoteNode | null;
+    pair(nodeId: string, pairingCode: string): Promise<boolean>;
+    sendCommand(nodeId: string, command: string): Promise<any>;
+    broadcast(command: string): Promise<Map<string, any>>;
+    healthCheck(): Promise<Map<string, boolean>>;
+}
+//# sourceMappingURL=node-network.d.ts.map