opc-agent 4.1.2 → 4.1.4

package/src/core/ide-bridge.ts

@@ -1,133 +0,0 @@
-import { execSync } from 'child_process';
-
-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 class IDEBridge {
-  private config: IDEConfig;
-
-  constructor(config: IDEConfig) {
-    this.config = config;
-  }
-
-  private getCliCommand(): string {
-    switch (this.config.editor) {
-      case 'vscode': case 'cursor': return this.config.editor === 'cursor' ? 'cursor' : 'code';
-      case 'jetbrains': return 'idea';
-      case 'zed': return 'zed';
-    }
-  }
-
-  private exec(cmd: string): string {
-    try {
-      return execSync(cmd, { encoding: 'utf-8', timeout: 10000, cwd: this.config.workspacePath }).trim();
-    } catch (e: any) {
-      throw new Error(`IDE command failed: ${e.message}`);
-    }
-  }
-
-  async openFile(path: string, line?: number): Promise<void> {
-    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?: string): Promise<Diagnostic[]> {
-    // VS Code doesn't expose diagnostics via CLI; return empty as stub
-    return [];
-  }
-
-  async runCommand(command: string): Promise<string> {
-    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(): Promise<string[]> {
-    // Stub — no standard CLI to get open files
-    return [];
-  }
-
-  async applyEdit(path: string, edits: TextEdit[]): Promise<void> {
-    // 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: string, options?: SearchOptions): Promise<SearchResult[]> {
-    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(): Promise<{ path: string; text: string; range: Range } | null> {
-    // Stub — requires editor extension
-    return null;
-  }
-
-  async installExtension(extensionId: string): Promise<void> {
-    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}`);
-    }
-  }
-}

package/src/core/knowledge.ts

@@ -1,255 +0,0 @@
-/**
- * Knowledge Base / RAG - Local vector storage with semantic search
- * Supports optional DeepBrain semantic search enhancement via OPC_DEEPBRAIN_ENABLED=true
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import { spawnSync } from 'child_process';
-
-// Simple in-memory vector store (PGlite-compatible interface for future migration)
-interface VectorEntry {
-  id: string;
-  content: string;
-  embedding: number[];
-  metadata: Record<string, unknown>;
-}
-
-interface KnowledgeStore {
-  entries: VectorEntry[];
-  version: number;
-  updatedAt: string;
-}
-
-const CHUNK_SIZE = 500; // chars per chunk
-const CHUNK_OVERLAP = 50;
-const STORE_FILE = '.opc-knowledge.json';
-
-function splitText(text: string, chunkSize = CHUNK_SIZE, overlap = CHUNK_OVERLAP): string[] {
-  const chunks: string[] = [];
-  // Split by paragraphs first, then by size
-  const paragraphs = text.split(/\n\s*\n/).filter(p => p.trim());
-  let current = '';
-
-  for (const para of paragraphs) {
-    if (current.length + para.length > chunkSize && current.length > 0) {
-      chunks.push(current.trim());
-      // Keep overlap from end of current
-      current = current.slice(-overlap) + '\n\n' + para;
-    } else {
-      current += (current ? '\n\n' : '') + para;
-    }
-  }
-  if (current.trim()) chunks.push(current.trim());
-
-  // If any chunk is still too large, split by sentences
-  const result: string[] = [];
-  for (const chunk of chunks) {
-    if (chunk.length <= chunkSize * 1.5) {
-      result.push(chunk);
-    } else {
-      const sentences = chunk.split(/(?<=[.!?])\s+/);
-      let buf = '';
-      for (const s of sentences) {
-        if (buf.length + s.length > chunkSize && buf) {
-          result.push(buf.trim());
-          buf = buf.slice(-overlap) + ' ' + s;
-        } else {
-          buf += (buf ? ' ' : '') + s;
-        }
-      }
-      if (buf.trim()) result.push(buf.trim());
-    }
-  }
-  return result;
-}
-
-// Simple TF-IDF-like embedding (no external dependencies)
-// For production, replace with real embedding API
-function simpleEmbed(text: string): number[] {
-  const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, '').split(/\s+/).filter(Boolean);
-  const dim = 128;
-  const vec = new Array(dim).fill(0);
-
-  for (const word of words) {
-    const hash = crypto.createHash('md5').update(word).digest();
-    for (let i = 0; i < dim; i++) {
-      vec[i] += (hash[i % hash.length] - 128) / 128;
-    }
-  }
-
-  // Normalize
-  const mag = Math.sqrt(vec.reduce((s, v) => s + v * v, 0)) || 1;
-  return vec.map(v => v / mag);
-}
-
-function cosineSimilarity(a: number[], b: number[]): number {
-  let dot = 0, magA = 0, magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  return dot / (Math.sqrt(magA) * Math.sqrt(magB) || 1);
-}
-
-export class KnowledgeBase {
-  private store: KnowledgeStore;
-  private storePath: string;
-
-  constructor(baseDir: string = '.') {
-    this.storePath = path.join(baseDir, STORE_FILE);
-    this.store = this.load();
-  }
-
-  private load(): KnowledgeStore {
-    try {
-      if (fs.existsSync(this.storePath)) {
-        return JSON.parse(fs.readFileSync(this.storePath, 'utf-8'));
-      }
-    } catch { /* ignore */ }
-    return { entries: [], version: 1, updatedAt: new Date().toISOString() };
-  }
-
-  private save(): void {
-    this.store.updatedAt = new Date().toISOString();
-    fs.writeFileSync(this.storePath, JSON.stringify(this.store), 'utf-8');
-  }
-
-  async addFile(filePath: string): Promise<{ chunks: number }> {
-    const absPath = path.resolve(filePath);
-    if (!fs.existsSync(absPath)) {
-      throw new Error(`File not found: ${absPath}`);
-    }
-
-    const content = fs.readFileSync(absPath, 'utf-8');
-    const filename = path.basename(absPath);
-
-    // Remove existing entries for this file
-    this.store.entries = this.store.entries.filter(
-      e => e.metadata.source !== filename
-    );
-
-    const chunks = splitText(content);
-    for (let i = 0; i < chunks.length; i++) {
-      const chunk = chunks[i];
-      this.store.entries.push({
-        id: `${filename}_${i}_${Date.now()}`,
-        content: chunk,
-        embedding: simpleEmbed(chunk),
-        metadata: {
-          source: filename,
-          chunkIndex: i,
-          totalChunks: chunks.length,
-          addedAt: new Date().toISOString(),
-        },
-      });
-    }
-
-    this.save();
-    return { chunks: chunks.length };
-  }
-
-  async addText(text: string, source: string = 'manual'): Promise<{ chunks: number }> {
-    const chunks = splitText(text);
-    for (let i = 0; i < chunks.length; i++) {
-      this.store.entries.push({
-        id: `${source}_${i}_${Date.now()}`,
-        content: chunks[i],
-        embedding: simpleEmbed(chunks[i]),
-        metadata: { source, chunkIndex: i, totalChunks: chunks.length, addedAt: new Date().toISOString() },
-      });
-    }
-    this.save();
-    return { chunks: chunks.length };
-  }
-
-  async search(query: string, topK: number = 5): Promise<Array<{ content: string; score: number; source: string }>> {
-    if (this.store.entries.length === 0) return [];
-
-    const queryEmb = simpleEmbed(query);
-    const scored = this.store.entries.map(entry => ({
-      content: entry.content,
-      score: cosineSimilarity(queryEmb, entry.embedding),
-      source: String(entry.metadata.source ?? 'unknown'),
-    }));
-
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, topK);
-  }
-
-  /** Build context string for injection into LLM calls */
-  async getContext(query: string, topK: number = 3, minScore: number = 0.1): Promise<string> {
-    const results = await this.search(query, topK);
-    const relevant = results.filter(r => r.score >= minScore);
-
-    let context = '';
-    if (relevant.length > 0) {
-      context = `\n\n--- Relevant Knowledge ---\n${relevant.map((r, i) =>
-        `[${i + 1}] (source: ${r.source}, relevance: ${(r.score * 100).toFixed(0)}%)\n${r.content}`
-      ).join('\n\n')}\n--- End Knowledge ---\n`;
-    }
-
-    // Enhance with DeepBrain semantic search if enabled
-    const deepBrainCtx = this.queryDeepBrain(query, topK);
-    return context + deepBrainCtx;
-  }
-
-  /**
-   * Query DeepBrain for semantic search enhancement.
-   * Activated when OPC_DEEPBRAIN_ENABLED=true and deepbrain CLI is globally installed.
-   */
-  private queryDeepBrain(query: string, topK: number): string {
-    if (process.env.OPC_DEEPBRAIN_ENABLED !== 'true') return '';
-
-    // Verify deepbrain is installed
-    const check = spawnSync('deepbrain', ['--version'], { encoding: 'utf-8', timeout: 3000 });
-    if (check.error || check.status !== 0) return '';
-
-    try {
-      const result = spawnSync(
-        'deepbrain',
-        ['query', query, '--top', String(topK), '--format', 'json'],
-        { encoding: 'utf-8', timeout: 5000 },
-      );
-      if (result.status !== 0 || !result.stdout?.trim()) return '';
-
-      type DeepBrainResult = { source?: string; score?: number; content?: string; text?: string };
-      const parsed: unknown = JSON.parse(result.stdout);
-      const items: DeepBrainResult[] = Array.isArray(parsed)
-        ? (parsed as DeepBrainResult[])
-        : ((parsed as { results?: DeepBrainResult[] }).results ?? []);
-
-      if (items.length === 0) return '';
-
-      return `\n\n--- DeepBrain Knowledge ---\n${items.map((r, i) => {
-        const relevance = r.score != null ? `${(r.score * 100).toFixed(0)}%` : 'n/a';
-        const text = r.content ?? r.text ?? '';
-        return `[${i + 1}] (source: ${r.source ?? 'deepbrain'}, relevance: ${relevance})\n${text}`;
-      }).join('\n\n')}\n--- End DeepBrain Knowledge ---\n`;
-    } catch {
-      return '';
-    }
-  }
-
-  getStats(): { totalEntries: number; sources: string[]; updatedAt: string } {
-    const sources = [...new Set(this.store.entries.map(e => String(e.metadata.source)))];
-    return {
-      totalEntries: this.store.entries.length,
-      sources,
-      updatedAt: this.store.updatedAt,
-    };
-  }
-
-  clear(): void {
-    this.store.entries = [];
-    this.save();
-  }
-
-  removeSource(source: string): number {
-    const before = this.store.entries.length;
-    this.store.entries = this.store.entries.filter(e => e.metadata.source !== source);
-    this.save();
-    return before - this.store.entries.length;
-  }
-}

package/src/core/logger.ts

@@ -1,57 +0,0 @@
-/**
- * Structured logger with log levels.
- */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-const LOG_LEVEL_ORDER: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-export class Logger {
-  private context: string;
-  private level: LogLevel;
-
-  constructor(context: string, level: LogLevel = 'info') {
-    this.context = context;
-    this.level = level;
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[this.level];
-  }
-
-  private format(level: LogLevel, message: string, data?: Record<string, unknown>): string {
-    const ts = new Date().toISOString();
-    const prefix = `[${ts}] [${level.toUpperCase()}] [${this.context}]`;
-    return data ? `${prefix} ${message} ${JSON.stringify(data)}` : `${prefix} ${message}`;
-  }
-
-  debug(message: string, data?: Record<string, unknown>): void {
-    if (this.shouldLog('debug')) console.debug(this.format('debug', message, data));
-  }
-
-  info(message: string, data?: Record<string, unknown>): void {
-    if (this.shouldLog('info')) console.info(this.format('info', message, data));
-  }
-
-  warn(message: string, data?: Record<string, unknown>): void {
-    if (this.shouldLog('warn')) console.warn(this.format('warn', message, data));
-  }
-
-  error(message: string, data?: Record<string, unknown>): void {
-    if (this.shouldLog('error')) console.error(this.format('error', message, data));
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level;
-  }
-
-  child(context: string): Logger {
-    return new Logger(`${this.context}:${context}`, this.level);
-  }
-}
-
-export const defaultLogger = new Logger('opc');

package/src/core/node-network.ts

@@ -1,86 +0,0 @@
-import { randomUUID } from 'crypto';
-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 class NodeNetwork extends EventEmitter {
-  private nodes = new Map<string, RemoteNode>();
-
-  addNode(config: Partial<RemoteNode>): RemoteNode {
-    const node: RemoteNode = {
-      id: config.id || randomUUID(),
-      name: config.name || 'unnamed',
-      host: config.host || 'localhost',
-      port: config.port || 8080,
-      type: config.type || 'desktop',
-      status: config.status || 'offline',
-      capabilities: config.capabilities || [],
-      lastSeen: Date.now(),
-    };
-    this.nodes.set(node.id, node);
-    return node;
-  }
-
-  removeNode(id: string): void {
-    if (!this.nodes.has(id)) throw new Error(`Node ${id} not found`);
-    this.nodes.delete(id);
-  }
-
-  listNodes(): RemoteNode[] {
-    return Array.from(this.nodes.values());
-  }
-
-  getNode(id: string): RemoteNode | null {
-    return this.nodes.get(id) || null;
-  }
-
-  async pair(nodeId: string, pairingCode: string): Promise<boolean> {
-    const node = this.nodes.get(nodeId);
-    if (!node) throw new Error(`Node ${nodeId} not found`);
-    if (!pairingCode || pairingCode.length < 4) return false;
-    node.status = 'online';
-    node.lastSeen = Date.now();
-    return true;
-  }
-
-  async sendCommand(nodeId: string, command: string): Promise<any> {
-    const node = this.nodes.get(nodeId);
-    if (!node) throw new Error(`Node ${nodeId} not found`);
-    if (node.status !== 'online') throw new Error(`Node ${nodeId} is ${node.status}`);
-    node.lastSeen = Date.now();
-    // Stub: return command echo
-    return { nodeId, command, status: 'sent', timestamp: Date.now() };
-  }
-
-  async broadcast(command: string): Promise<Map<string, any>> {
-    const results = new Map<string, any>();
-    for (const [id, node] of this.nodes) {
-      if (node.status === 'online') {
-        try {
-          results.set(id, await this.sendCommand(id, command));
-        } catch (e: any) {
-          results.set(id, { error: e.message });
-        }
-      }
-    }
-    return results;
-  }
-
-  async healthCheck(): Promise<Map<string, boolean>> {
-    const results = new Map<string, boolean>();
-    for (const [id, node] of this.nodes) {
-      results.set(id, node.status === 'online');
-      node.lastSeen = Date.now();
-    }
-    return results;
-  }
-}