opc-agent 4.0.0 → 4.0.2

package/src/tools/builtin/index.ts

@@ -1,35 +1,37 @@
-import type { MCPTool } from '../mcp';
-import { fileTool } from './file';
-import { webTool } from './web';
-import { shellTool } from './shell';
-import { datetimeTool } from './datetime';
-import { browserTools, BrowserManager, browserManager } from './browser';
-import { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool } from './vision';
-import { rlTools } from './rl-tools';
-import { homeAssistantTools } from './home-assistant';
-
-export { fileTool, webTool, shellTool, datetimeTool, browserTools, BrowserManager, browserManager };
-export { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool };
-export { rlTools } from './rl-tools';
-export { homeAssistantTools, configureHomeAssistant } from './home-assistant';
-
-const ALL_BUILTIN_TOOLS: MCPTool[] = [fileTool, webTool, shellTool, datetimeTool, ...browserTools, ...visionTools, ...rlTools, ...homeAssistantTools];
-
-const BUILTIN_MAP = new Map<string, MCPTool>(
-  ALL_BUILTIN_TOOLS.map(t => [t.name, t])
-);
-
-/**
- * Get all built-in tools.
- */
-export function getBuiltinTools(): MCPTool[] {
-  return [...ALL_BUILTIN_TOOLS];
-}
-
-/**
- * Get specific built-in tools by name. If no names given, returns all.
- */
-export function getBuiltinToolsByName(names?: string[]): MCPTool[] {
-  if (!names || names.length === 0) return getBuiltinTools();
-  return names.map(n => BUILTIN_MAP.get(n)).filter((t): t is MCPTool => !!t);
-}
+import type { MCPTool } from '../mcp';
+import { fileTool } from './file';
+import { webTool } from './web';
+import { shellTool } from './shell';
+import { datetimeTool } from './datetime';
+import { browserTools, BrowserManager, browserManager } from './browser';
+import { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool } from './vision';
+import { rlTools } from './rl-tools';
+import { homeAssistantTools } from './home-assistant';
+import { webSearchTools, webSearchTool, webReadTool } from './web-search';
+
+export { fileTool, webTool, shellTool, datetimeTool, browserTools, BrowserManager, browserManager };
+export { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool };
+export { rlTools } from './rl-tools';
+export { homeAssistantTools, configureHomeAssistant } from './home-assistant';
+export { webSearchTools, webSearchTool, webReadTool } from './web-search';
+
+const ALL_BUILTIN_TOOLS: MCPTool[] = [fileTool, webTool, shellTool, datetimeTool, ...browserTools, ...visionTools, ...rlTools, ...homeAssistantTools, ...webSearchTools];
+
+const BUILTIN_MAP = new Map<string, MCPTool>(
+  ALL_BUILTIN_TOOLS.map(t => [t.name, t])
+);
+
+/**
+ * Get all built-in tools.
+ */
+export function getBuiltinTools(): MCPTool[] {
+  return [...ALL_BUILTIN_TOOLS];
+}
+
+/**
+ * Get specific built-in tools by name. If no names given, returns all.
+ */
+export function getBuiltinToolsByName(names?: string[]): MCPTool[] {
+  if (!names || names.length === 0) return getBuiltinTools();
+  return names.map(n => BUILTIN_MAP.get(n)).filter((t): t is MCPTool => !!t);
+}

package/src/tools/builtin/web-search.ts

@@ -0,0 +1,126 @@
+/**
+ * Web Search & Read Built-in Tools - v0.10.0
+ * Registers web_search and web_read as agent-callable tools.
+ */
+
+import type { MCPTool, MCPToolResult } from '../mcp';
+import { webSearch, DEFAULT_SEARCH_CONFIG, type WebSearchConfig, type SearchEngine } from '../web-search';
+import { scrapeUrl } from '../web-scraper';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import * as os from 'os';
+
+function loadSearchConfig(): WebSearchConfig {
+  try {
+    const cfgPath = join(os.homedir(), '.opc', 'config.json');
+    if (existsSync(cfgPath)) {
+      const cfg = JSON.parse(readFileSync(cfgPath, 'utf-8'));
+      if (cfg.webSearch) {
+        return { ...DEFAULT_SEARCH_CONFIG, ...cfg.webSearch };
+      }
+    }
+  } catch { /* ignore */ }
+  return DEFAULT_SEARCH_CONFIG;
+}
+
+export const webSearchTool: MCPTool = {
+  name: 'web_search',
+  description: 'Search the internet for information. Returns titles, URLs, and snippets from search results. Use when you need current information or facts you\'re unsure about.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Search query string',
+      },
+      maxResults: {
+        type: 'number',
+        description: 'Maximum number of results to return (default: 5)',
+      },
+      engine: {
+        type: 'string',
+        enum: ['duckduckgo', 'brave', 'searxng', 'google'],
+        description: 'Search engine to use (default: configured engine)',
+      },
+    },
+    required: ['query'],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const query = String(input.query ?? '');
+    if (!query.trim()) {
+      return { content: 'Error: empty search query', isError: true };
+    }
+
+    const config = loadSearchConfig();
+    if (!config.enabled) {
+      return { content: 'Web search is disabled in settings.', isError: true };
+    }
+
+    try {
+      const results = await webSearch(query, config, {
+        maxResults: (input.maxResults as number) || 5,
+        engine: input.engine as SearchEngine | undefined,
+      });
+
+      if (results.length === 0) {
+        return { content: `No results found for: ${query}` };
+      }
+
+      const formatted = results.map((r, i) =>
+        `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`
+      ).join('\n\n');
+
+      return {
+        content: `Search results for "${query}":\n\n${formatted}`,
+        metadata: { resultCount: results.length, query },
+      };
+    } catch (err) {
+      return {
+        content: `Search error: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true,
+      };
+    }
+  },
+};
+
+export const webReadTool: MCPTool = {
+  name: 'web_read',
+  description: 'Read and extract the main content from a web page URL. Returns clean markdown text. Use to get detailed information from a specific page.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: {
+        type: 'string',
+        description: 'URL of the web page to read',
+      },
+      maxLength: {
+        type: 'number',
+        description: 'Maximum content length in characters (default: 5000)',
+      },
+    },
+    required: ['url'],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const url = String(input.url ?? '');
+    if (!url.trim()) {
+      return { content: 'Error: empty URL', isError: true };
+    }
+
+    try {
+      const result = await scrapeUrl(url, (input.maxLength as number) || 5000);
+      return {
+        content: `# ${result.title}\n\nSource: ${result.url}\nWords: ${result.wordCount}\n\n---\n\n${result.content}`,
+        metadata: { title: result.title, url: result.url, wordCount: result.wordCount },
+      };
+    } catch (err) {
+      return {
+        content: `Scrape error: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true,
+      };
+    }
+  },
+};
+
+export const webSearchTools: MCPTool[] = [webSearchTool, webReadTool];

package/src/tools/document-processor.ts

@@ -0,0 +1,213 @@
+/**
+ * Document Processor - Parse and chunk documents for knowledge learning
+ * Supports: PDF, TXT, MD, DOCX, CSV, JSON
+ */
+
+export interface DocumentChunk {
+  title: string;
+  content: string;
+  metadata: {
+    source: string;
+    format: string;
+    chunkIndex: number;
+    totalChunks?: number;
+    page?: number;
+  };
+}
+
+export interface ProcessedDocument {
+  id: string;
+  filename: string;
+  format: string;
+  size: number;
+  chunks: DocumentChunk[];
+  processedAt: string;
+}
+
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+const CHUNK_TARGET_CHARS = 2000; // ~500 tokens
+const CHUNK_MAX_CHARS = 4000; // ~1000 tokens
+
+export class DocumentProcessor {
+  /**
+   * Process a file buffer into chunks
+   */
+  async process(buffer: Buffer, filename: string): Promise<ProcessedDocument> {
+    if (buffer.length > MAX_FILE_SIZE) {
+      throw new Error(`File too large: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (max 50MB)`);
+    }
+
+    const ext = filename.split('.').pop()?.toLowerCase() || '';
+    let rawText: string;
+
+    switch (ext) {
+      case 'pdf':
+        rawText = await this.parsePDF(buffer);
+        break;
+      case 'docx':
+        rawText = await this.parseDOCX(buffer);
+        break;
+      case 'csv':
+        rawText = this.parseCSV(buffer.toString('utf-8'));
+        break;
+      case 'json':
+        rawText = this.parseJSON(buffer.toString('utf-8'));
+        break;
+      case 'txt':
+      case 'md':
+      case 'markdown':
+        rawText = buffer.toString('utf-8');
+        break;
+      default:
+        // Try as plain text
+        rawText = buffer.toString('utf-8');
+    }
+
+    const chunks = this.chunkText(rawText, filename, ext);
+
+    return {
+      id: `doc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      filename,
+      format: ext,
+      size: buffer.length,
+      chunks,
+      processedAt: new Date().toISOString(),
+    };
+  }
+
+  private async parsePDF(buffer: Buffer): Promise<string> {
+    try {
+      const pdfParse = require('pdf-parse');
+      const data = await pdfParse(buffer);
+      return data.text || '';
+    } catch (e: any) {
+      throw new Error(`PDF parse failed: ${e.message}`);
+    }
+  }
+
+  private async parseDOCX(buffer: Buffer): Promise<string> {
+    try {
+      const mammoth = require('mammoth');
+      const result = await mammoth.extractRawText({ buffer });
+      return result.value || '';
+    } catch (e: any) {
+      throw new Error(`DOCX parse failed: ${e.message}`);
+    }
+  }
+
+  private parseCSV(text: string): string {
+    const lines = text.split('\n').filter(l => l.trim());
+    if (lines.length === 0) return '';
+
+    const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+    const rows = lines.slice(1);
+
+    // Convert CSV to readable text
+    return rows.map((row, i) => {
+      const values = this.parseCSVLine(row);
+      const pairs = headers.map((h, j) => `${h}: ${values[j] || ''}`);
+      return `Record ${i + 1}:\n${pairs.join('\n')}`;
+    }).join('\n\n');
+  }
+
+  private parseCSVLine(line: string): string[] {
+    const result: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    for (const ch of line) {
+      if (ch === '"') { inQuotes = !inQuotes; }
+      else if (ch === ',' && !inQuotes) { result.push(current.trim()); current = ''; }
+      else { current += ch; }
+    }
+    result.push(current.trim());
+    return result;
+  }
+
+  private parseJSON(text: string): string {
+    try {
+      const data = JSON.parse(text);
+      if (Array.isArray(data)) {
+        return data.map((item, i) => `Item ${i + 1}:\n${JSON.stringify(item, null, 2)}`).join('\n\n');
+      }
+      return JSON.stringify(data, null, 2);
+    } catch {
+      return text;
+    }
+  }
+
+  /**
+   * Smart chunking: split by headings/paragraphs, respecting size limits
+   */
+  private chunkText(text: string, filename: string, format: string): DocumentChunk[] {
+    if (!text.trim()) return [];
+
+    // Split by markdown headings or double newlines
+    const sections = text.split(/\n(?=#{1,3}\s)|(?:\n\s*\n)/).filter(s => s.trim());
+    const chunks: DocumentChunk[] = [];
+    let currentChunk = '';
+    let currentTitle = filename;
+
+    for (const section of sections) {
+      const headingMatch = section.match(/^(#{1,3})\s+(.+)/);
+      if (headingMatch) {
+        currentTitle = headingMatch[2].trim();
+      }
+
+      if (currentChunk.length + section.length > CHUNK_MAX_CHARS && currentChunk.length > 0) {
+        chunks.push({
+          title: currentTitle,
+          content: currentChunk.trim(),
+          metadata: { source: filename, format, chunkIndex: chunks.length },
+        });
+        currentChunk = '';
+      }
+
+      currentChunk += section + '\n\n';
+
+      if (currentChunk.length >= CHUNK_TARGET_CHARS) {
+        chunks.push({
+          title: currentTitle,
+          content: currentChunk.trim(),
+          metadata: { source: filename, format, chunkIndex: chunks.length },
+        });
+        currentChunk = '';
+      }
+    }
+
+    if (currentChunk.trim()) {
+      chunks.push({
+        title: currentTitle,
+        content: currentChunk.trim(),
+        metadata: { source: filename, format, chunkIndex: chunks.length },
+      });
+    }
+
+    // If we got no chunks from section splitting (e.g. dense text), force-split
+    if (chunks.length === 0 && text.trim()) {
+      const words = text.split(/\s+/);
+      let buf = '';
+      for (const w of words) {
+        if (buf.length + w.length + 1 > CHUNK_MAX_CHARS && buf) {
+          chunks.push({
+            title: filename,
+            content: buf.trim(),
+            metadata: { source: filename, format, chunkIndex: chunks.length },
+          });
+          buf = '';
+        }
+        buf += w + ' ';
+      }
+      if (buf.trim()) {
+        chunks.push({
+          title: filename,
+          content: buf.trim(),
+          metadata: { source: filename, format, chunkIndex: chunks.length },
+        });
+      }
+    }
+
+    // Set totalChunks
+    for (const c of chunks) c.metadata.totalChunks = chunks.length;
+    return chunks;
+  }
+}

package/src/tools/image-generator.ts

@@ -0,0 +1,150 @@
+/**
+ * Image Generator — multi-backend image generation tool.
+ * Supports DALL·E (OpenAI), Stable Diffusion (local), and Replicate.
+ */
+
+export interface ImageGenConfig {
+  provider?: 'dalle' | 'stable-diffusion' | 'replicate';
+  openaiApiKey?: string;
+  replicateApiKey?: string;
+  sdApiUrl?: string;
+  defaultModel?: string;
+  defaultSize?: string;
+}
+
+export interface ImageGenResult {
+  success: boolean;
+  url?: string;
+  base64?: string;
+  error?: string;
+  provider: string;
+}
+
+export class ImageGenerator {
+  private config: ImageGenConfig;
+
+  constructor(config?: ImageGenConfig) {
+    this.config = {
+      provider: config?.provider,
+      openaiApiKey: config?.openaiApiKey || process.env.OPENAI_API_KEY,
+      replicateApiKey: config?.replicateApiKey || process.env.REPLICATE_API_TOKEN,
+      sdApiUrl: config?.sdApiUrl || process.env.SD_API_URL,
+      defaultModel: config?.defaultModel || 'dall-e-3',
+      defaultSize: config?.defaultSize || '1024x1024',
+    };
+  }
+
+  /** Auto-detect best available provider */
+  detectProvider(): string | null {
+    if (this.config.openaiApiKey) return 'dalle';
+    if (this.config.sdApiUrl) return 'stable-diffusion';
+    if (this.config.replicateApiKey) return 'replicate';
+    return null;
+  }
+
+  /** Get configuration status for the settings UI */
+  getStatus(): { configured: boolean; providers: { name: string; configured: boolean }[] } {
+    return {
+      configured: !!this.detectProvider(),
+      providers: [
+        { name: 'dalle', configured: !!this.config.openaiApiKey },
+        { name: 'stable-diffusion', configured: !!this.config.sdApiUrl },
+        { name: 'replicate', configured: !!this.config.replicateApiKey },
+      ],
+    };
+  }
+
+  async generate(prompt: string, options?: { provider?: string; size?: string; model?: string }): Promise<ImageGenResult> {
+    const provider = options?.provider || this.config.provider || this.detectProvider();
+    if (!provider) {
+      return { success: false, error: 'No image generation provider configured. Please set OPENAI_API_KEY, SD_API_URL, or REPLICATE_API_TOKEN.', provider: 'none' };
+    }
+
+    switch (provider) {
+      case 'dalle': return this.generateDalle(prompt, options);
+      case 'stable-diffusion': return this.generateSD(prompt, options);
+      case 'replicate': return this.generateReplicate(prompt, options);
+      default: return { success: false, error: `Unknown provider: ${provider}`, provider };
+    }
+  }
+
+  private async generateDalle(prompt: string, options?: { size?: string; model?: string }): Promise<ImageGenResult> {
+    const apiKey = this.config.openaiApiKey;
+    if (!apiKey) return { success: false, error: 'OPENAI_API_KEY not configured', provider: 'dalle' };
+
+    try {
+      const res = await fetch('https://api.openai.com/v1/images/generations', {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: options?.model || this.config.defaultModel || 'dall-e-3',
+          prompt,
+          size: options?.size || this.config.defaultSize || '1024x1024',
+          n: 1,
+        }),
+      });
+      const data = await res.json() as { data?: Array<{ url: string }>; error?: { message: string } };
+      if (data.error) return { success: false, error: data.error.message, provider: 'dalle' };
+      const url = data.data?.[0]?.url;
+      return url ? { success: true, url, provider: 'dalle' } : { success: false, error: 'No image returned', provider: 'dalle' };
+    } catch (err) {
+      return { success: false, error: (err as Error).message, provider: 'dalle' };
+    }
+  }
+
+  private async generateSD(prompt: string, options?: { size?: string }): Promise<ImageGenResult> {
+    const apiUrl = this.config.sdApiUrl;
+    if (!apiUrl) return { success: false, error: 'SD_API_URL not configured', provider: 'stable-diffusion' };
+
+    try {
+      const [w, h] = (options?.size || '1024x1024').split('x').map(Number);
+      const res = await fetch(`${apiUrl}/sdapi/v1/txt2img`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ prompt, width: w || 1024, height: h || 1024 }),
+      });
+      const data = await res.json() as { images?: string[] };
+      if (data.images?.length) {
+        return { success: true, base64: data.images[0], provider: 'stable-diffusion' };
+      }
+      return { success: false, error: 'No image generated', provider: 'stable-diffusion' };
+    } catch (err) {
+      return { success: false, error: (err as Error).message, provider: 'stable-diffusion' };
+    }
+  }
+
+  private async generateReplicate(prompt: string, _options?: { model?: string }): Promise<ImageGenResult> {
+    const apiKey = this.config.replicateApiKey;
+    if (!apiKey) return { success: false, error: 'REPLICATE_API_TOKEN not configured', provider: 'replicate' };
+
+    try {
+      const res = await fetch('https://api.replicate.com/v1/predictions', {
+        method: 'POST',
+        headers: { 'Authorization': `Token ${apiKey}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          version: 'stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b',
+          input: { prompt },
+        }),
+      });
+      const prediction = await res.json() as { id: string; urls?: { get: string }; error?: string };
+      if (prediction.error) return { success: false, error: prediction.error, provider: 'replicate' };
+
+      // Poll for completion (max 60s)
+      const getUrl = prediction.urls?.get || `https://api.replicate.com/v1/predictions/${prediction.id}`;
+      for (let i = 0; i < 30; i++) {
+        await new Promise(r => setTimeout(r, 2000));
+        const poll = await fetch(getUrl, { headers: { 'Authorization': `Token ${apiKey}` } });
+        const result = await poll.json() as { status: string; output?: string[]; error?: string };
+        if (result.status === 'succeeded' && result.output?.length) {
+          return { success: true, url: result.output[0], provider: 'replicate' };
+        }
+        if (result.status === 'failed') {
+          return { success: false, error: result.error || 'Generation failed', provider: 'replicate' };
+        }
+      }
+      return { success: false, error: 'Timeout waiting for image generation', provider: 'replicate' };
+    } catch (err) {
+      return { success: false, error: (err as Error).message, provider: 'replicate' };
+    }
+  }
+}