opc-agent 4.1.1 → 4.1.3

package/src/core/vision.ts

@@ -1,180 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-// ─── Types ───────────────────────────────────────────────────
-
-export interface ImageInput {
-  type: 'base64' | 'url' | 'file';
-  data: string;
-  mimeType?: string;
-}
-
-export interface VisionResult {
-  description: string;
-  text_content?: string;
-  objects?: string[];
-}
-
-// ─── MIME detection from magic bytes ─────────────────────────
-
-const MAGIC_BYTES: Array<{ bytes: number[]; mime: string }> = [
-  { bytes: [0x89, 0x50, 0x4E, 0x47], mime: 'image/png' },
-  { bytes: [0xFF, 0xD8, 0xFF], mime: 'image/jpeg' },
-  { bytes: [0x47, 0x49, 0x46, 0x38], mime: 'image/gif' },
-  { bytes: [0x52, 0x49, 0x46, 0x46], mime: 'image/webp' }, // RIFF header (WebP)
-];
-
-export function detectMimeType(buffer: Buffer): string {
-  for (const { bytes, mime } of MAGIC_BYTES) {
-    if (bytes.every((b, i) => buffer[i] === b)) {
-      return mime;
-    }
-  }
-  return 'application/octet-stream';
-}
-
-// ─── VisionManager ───────────────────────────────────────────
-
-export interface VisionManagerConfig {
-  model?: string;
-  apiKey?: string;
-  baseURL?: string;
-  maxImageSize?: number; // bytes, default 20MB
-}
-
-export class VisionManager {
-  private config: VisionManagerConfig;
-
-  constructor(config: VisionManagerConfig = {}) {
-    this.config = {
-      model: config.model ?? 'gpt-4o',
-      apiKey: config.apiKey ?? process.env.OPENAI_API_KEY ?? '',
-      baseURL: config.baseURL ?? 'https://api.openai.com/v1',
-      maxImageSize: config.maxImageSize ?? 20 * 1024 * 1024,
-    };
-  }
-
-  /**
-   * Load image data as base64, detecting MIME type.
-   */
-  async loadImage(input: ImageInput): Promise<{ base64: string; mimeType: string }> {
-    if (input.type === 'base64') {
-      const buf = Buffer.from(input.data, 'base64');
-      return { base64: input.data, mimeType: input.mimeType ?? detectMimeType(buf) };
-    }
-    if (input.type === 'file') {
-      const buf = fs.readFileSync(input.data);
-      if (buf.length > this.config.maxImageSize!) {
-        throw new Error(`Image exceeds max size: ${buf.length} > ${this.config.maxImageSize}`);
-      }
-      return { base64: buf.toString('base64'), mimeType: input.mimeType ?? detectMimeType(buf) };
-    }
-    // URL — return as-is for API
-    return { base64: '', mimeType: input.mimeType ?? 'image/jpeg' };
-  }
-
-  /**
-   * Prepare messages in OpenAI multimodal format.
-   */
-  prepareMessage(images: ImageInput[], text: string): Array<Record<string, unknown>> {
-    const content: Array<Record<string, unknown>> = [];
-    if (text) {
-      content.push({ type: 'text', text });
-    }
-    for (const img of images) {
-      if (img.type === 'url') {
-        content.push({
-          type: 'image_url',
-          image_url: { url: img.data },
-        });
-      } else {
-        // base64 or file — will need to be loaded first
-        const mime = img.mimeType ?? 'image/jpeg';
-        const data = img.type === 'base64' ? img.data : fs.readFileSync(img.data).toString('base64');
-        content.push({
-          type: 'image_url',
-          image_url: { url: `data:${mime};base64,${data}` },
-        });
-      }
-    }
-    return [{ role: 'user', content }];
-  }
-
-  /**
-   * Analyze an image with optional prompt.
-   */
-  async analyze(image: ImageInput, prompt?: string): Promise<VisionResult> {
-    const messages = this.prepareMessage([image], prompt ?? 'Describe this image in detail.');
-
-    if (!this.config.apiKey) {
-      throw new Error('Vision API key not configured. Set OPENAI_API_KEY or pass apiKey in config.');
-    }
-
-    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.config.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: this.config.model,
-        messages,
-        max_tokens: 1000,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Vision API error: ${response.status} ${response.statusText}`);
-    }
-
-    const data = await response.json() as any;
-    const text = data.choices?.[0]?.message?.content ?? '';
-
-    return {
-      description: text,
-      text_content: undefined,
-      objects: [],
-    };
-  }
-
-  /**
-   * Extract text (OCR) from an image.
-   */
-  async extractText(image: ImageInput): Promise<string> {
-    const result = await this.analyze(image, 'Extract all visible text from this image. Return only the text, nothing else.');
-    return result.description;
-  }
-
-  /**
-   * Compare multiple images.
-   */
-  async compareImages(images: ImageInput[], prompt?: string): Promise<string> {
-    if (images.length < 2) throw new Error('Need at least 2 images to compare');
-
-    const messages = this.prepareMessage(images, prompt ?? 'Compare these images and describe the differences.');
-
-    if (!this.config.apiKey) {
-      throw new Error('Vision API key not configured.');
-    }
-
-    const response = await fetch(`${this.config.baseURL}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.config.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: this.config.model,
-        messages,
-        max_tokens: 1000,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Vision API error: ${response.status} ${response.statusText}`);
-    }
-
-    const data = await response.json() as any;
-    return data.choices?.[0]?.message?.content ?? '';
-  }
-}

package/src/core/watch.ts

@@ -1,178 +0,0 @@
-import { EventEmitter } from 'events';
-
-/**
- * ProcessWatcher — Background process output monitoring with pattern matching.
- *
- * Inspired by Hermes Agent's watch_patterns feature.
- * Set patterns to watch for in background process output and get callbacks
- * when they match — no polling needed.
- *
- * Usage:
- *   const watcher = new ProcessWatcher();
- *   watcher.watch(childProcess.stdout, {
- *     patterns: [
- *       { regex: /listening on port (\d+)/, label: 'server-ready' },
- *       { regex: /error|Error|ERROR/, label: 'error-detected' },
- *       { regex: /build completed/, label: 'build-done', once: true },
- *     ],
- *     onMatch: (match) => console.log(`[${match.label}] ${match.line}`),
- *   });
- */
-
-export interface WatchPattern {
-  /** Regex to match against each line of output */
-  regex: RegExp;
-  /** Human-readable label for this pattern */
-  label: string;
-  /** If true, auto-remove after first match */
-  once?: boolean;
-}
-
-export interface WatchMatch {
-  /** Pattern label */
-  label: string;
-  /** The full line that matched */
-  line: string;
-  /** Regex match groups */
-  groups: string[];
-  /** Timestamp of match */
-  timestamp: number;
-  /** Stream source */
-  stream: 'stdout' | 'stderr';
-}
-
-export interface WatchOptions {
-  /** Patterns to match */
-  patterns: WatchPattern[];
-  /** Callback on match */
-  onMatch: (match: WatchMatch) => void;
-  /** Optional: max matches to keep in history (default: 100) */
-  maxHistory?: number;
-}
-
-export class ProcessWatcher extends EventEmitter {
-  private watchers = new Map<string, {
-    patterns: WatchPattern[];
-    onMatch: (match: WatchMatch) => void;
-    history: WatchMatch[];
-    maxHistory: number;
-  }>();
-
-  private watcherIdCounter = 0;
-
-  /**
-   * Start watching a readable stream for patterns.
-   * Returns a watcher ID that can be used to stop watching.
-   */
-  watch(
-    stream: NodeJS.ReadableStream,
-    options: WatchOptions,
-    streamName: 'stdout' | 'stderr' = 'stdout',
-  ): string {
-    const id = `watcher_${++this.watcherIdCounter}`;
-    const state = {
-      patterns: [...options.patterns],
-      onMatch: options.onMatch,
-      history: [] as WatchMatch[],
-      maxHistory: options.maxHistory ?? 100,
-    };
-    this.watchers.set(id, state);
-
-    let buffer = '';
-
-    const onData = (chunk: Buffer | string) => {
-      buffer += chunk.toString();
-      const lines = buffer.split('\n');
-      buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        this.matchLine(id, line, streamName);
-      }
-    };
-
-    stream.on('data', onData);
-    stream.on('end', () => {
-      // Process remaining buffer
-      if (buffer) this.matchLine(id, buffer, streamName);
-      this.watchers.delete(id);
-      this.emit('watcher:end', id);
-    });
-
-    return id;
-  }
-
-  /**
-   * Watch both stdout and stderr of a ChildProcess.
-   */
-  watchProcess(
-    proc: { stdout?: NodeJS.ReadableStream | null; stderr?: NodeJS.ReadableStream | null },
-    options: WatchOptions,
-  ): string[] {
-    const ids: string[] = [];
-    if (proc.stdout) ids.push(this.watch(proc.stdout, options, 'stdout'));
-    if (proc.stderr) ids.push(this.watch(proc.stderr, options, 'stderr'));
-    return ids;
-  }
-
-  /** Stop a specific watcher */
-  unwatch(id: string): void {
-    this.watchers.delete(id);
-  }
-
-  /** Get match history for a watcher */
-  getHistory(id: string): WatchMatch[] {
-    return this.watchers.get(id)?.history ?? [];
-  }
-
-  /** Add a pattern to an existing watcher */
-  addPattern(id: string, pattern: WatchPattern): void {
-    const state = this.watchers.get(id);
-    if (state) state.patterns.push(pattern);
-  }
-
-  /** Remove a pattern by label from a watcher */
-  removePattern(id: string, label: string): void {
-    const state = this.watchers.get(id);
-    if (state) {
-      state.patterns = state.patterns.filter(p => p.label !== label);
-    }
-  }
-
-  private matchLine(watcherId: string, line: string, stream: 'stdout' | 'stderr'): void {
-    const state = this.watchers.get(watcherId);
-    if (!state) return;
-
-    const toRemove: number[] = [];
-
-    for (let i = 0; i < state.patterns.length; i++) {
-      const pattern = state.patterns[i];
-      const m = line.match(pattern.regex);
-      if (m) {
-        const match: WatchMatch = {
-          label: pattern.label,
-          line,
-          groups: m.slice(1),
-          timestamp: Date.now(),
-          stream,
-        };
-
-        state.history.push(match);
-        if (state.history.length > state.maxHistory) {
-          state.history.shift();
-        }
-
-        state.onMatch(match);
-        this.emit('match', match);
-
-        if (pattern.once) {
-          toRemove.push(i);
-        }
-      }
-    }
-
-    // Remove once-patterns in reverse order
-    for (let i = toRemove.length - 1; i >= 0; i--) {
-      state.patterns.splice(toRemove[i], 1);
-    }
-  }
-}