prepia 1.0.0

package/src/client/websocket.mjs

@@ -0,0 +1,353 @@
+/**
+ * Prepia WebSocket Server
+ * Real-time streaming and bidirectional communication
+ * Built on top of Node.js built-in modules
+ */
+
+import { EventEmitter } from 'events';
+import crypto from 'crypto';
+
+/**
+ * Simple WebSocket frame parser/builder (RFC 6455)
+ * No external dependencies needed
+ */
+class WebSocketFrame {
+  /**
+   * Parse a WebSocket frame from buffer
+   * @param {Buffer} buffer
+   * @returns {{ fin: boolean, opcode: number, payload: Buffer, bytesRead: number }|null}
+   */
+  static parse(buffer) {
+    if (buffer.length < 2) return null;
+
+    const firstByte = buffer[0];
+    const secondByte = buffer[1];
+    const fin = (firstByte & 0x80) !== 0;
+    const opcode = firstByte & 0x0f;
+    const masked = (secondByte & 0x80) !== 0;
+    let payloadLength = secondByte & 0x7f;
+    let offset = 2;
+
+    if (payloadLength === 126) {
+      if (buffer.length < 4) return null;
+      payloadLength = buffer.readUInt16BE(2);
+      offset = 4;
+    } else if (payloadLength === 127) {
+      if (buffer.length < 10) return null;
+      payloadLength = Number(buffer.readBigUInt64BE(2));
+      offset = 10;
+    }
+
+    const maskLength = masked ? 4 : 0;
+    const totalLength = offset + maskLength + payloadLength;
+    if (buffer.length < totalLength) return null;
+
+    let payload = buffer.slice(offset + maskLength, totalLength);
+    if (masked) {
+      const mask = buffer.slice(offset, offset + 4);
+      for (let i = 0; i < payload.length; i++) {
+        payload[i] ^= mask[i % 4];
+      }
+    }
+
+    return { fin, opcode, payload, bytesRead: totalLength };
+  }
+
+  /**
+   * Build a WebSocket frame
+   * @param {Buffer|string} data
+   * @param {number} [opcode=1] - 1=text, 2=binary, 8=close, 9=ping, 10=pong
+   * @returns {Buffer}
+   */
+  static build(data, opcode = 1) {
+    const payload = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const mask = crypto.randomBytes(4);
+    let header;
+
+    if (payload.length < 126) {
+      header = Buffer.alloc(2);
+      header[0] = 0x80 | opcode;
+      header[1] = 0x80 | payload.length;
+    } else if (payload.length < 65536) {
+      header = Buffer.alloc(4);
+      header[0] = 0x80 | opcode;
+      header[1] = 0x80 | 126;
+      header.writeUInt16BE(payload.length, 2);
+    } else {
+      header = Buffer.alloc(10);
+      header[0] = 0x80 | opcode;
+      header[1] = 0x80 | 127;
+      header.writeBigUInt64BE(BigInt(payload.length), 2);
+    }
+
+    // Mask the payload (server -> client doesn't need masking per spec, but we keep it simple)
+    const maskedPayload = Buffer.alloc(payload.length);
+    for (let i = 0; i < payload.length; i++) {
+      maskedPayload[i] = payload[i] ^ mask[i % 4];
+    }
+
+    return Buffer.concat([header, mask, maskedPayload]);
+  }
+}
+
+/**
+ * Individual WebSocket connection
+ */
+export class WebSocketConnection extends EventEmitter {
+  /**
+   * @param {import('net').Socket} socket
+   * @param {string} id
+   */
+  constructor(socket, id) {
+    super();
+    this.socket = socket;
+    this.id = id;
+    this.alive = true;
+    this.buffer = Buffer.alloc(0);
+    this.metadata = {};
+
+    this.socket.on('data', (chunk) => this._onData(chunk));
+    this.socket.on('close', () => {
+      this.alive = false;
+      clearInterval(this._pingInterval);
+      this.emit('close');
+    });
+    this.socket.on('end', () => {
+      // Client disconnected — close our side too
+      if (this.alive) {
+        this.alive = false;
+        clearInterval(this._pingInterval);
+        this.socket.end();
+        this.emit('close');
+      }
+    });
+    this.socket.on('error', (err) => {
+      if (this.alive) {
+        this.alive = false;
+        clearInterval(this._pingInterval);
+        this.emit('close');
+      }
+      this.emit('error', err);
+    });
+
+    // Ping/pong keepalive
+    this._pingInterval = setInterval(() => {
+      if (this.alive) this.ping();
+    }, 30000);
+  }
+
+  _onData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+
+    while (this.buffer.length > 0) {
+      const frame = WebSocketFrame.parse(this.buffer);
+      if (!frame) break;
+
+      this.buffer = this.buffer.slice(frame.bytesRead);
+
+      switch (frame.opcode) {
+        case 0x01: // Text frame
+          this.emit('message', frame.payload.toString());
+          break;
+        case 0x02: // Binary frame
+          this.emit('message', frame.payload);
+          break;
+        case 0x08: // Close
+          this.close();
+          break;
+        case 0x09: // Ping
+          this.pong();
+          break;
+        case 0x0a: // Pong
+          this.alive = true;
+          break;
+      }
+    }
+  }
+
+  /**
+   * Send data to the client
+   * @param {string|Buffer|Object} data
+   */
+  send(data) {
+    if (!this.alive) return;
+    const payload = typeof data === 'object' && !Buffer.isBuffer(data) ? JSON.stringify(data) : data;
+    const frame = WebSocketFrame.build(payload, typeof payload === 'string' ? 0x01 : 0x02);
+    try {
+      this.socket.write(frame);
+    } catch {
+      this.alive = false;
+    }
+  }
+
+  /**
+   * Send a ping
+   */
+  ping() {
+    if (!this.alive) return;
+    try {
+      const frame = WebSocketFrame.build(Buffer.alloc(0), 0x09);
+      this.socket.write(frame);
+    } catch {
+      this.alive = false;
+    }
+  }
+
+  /**
+   * Send a pong
+   */
+  pong() {
+    if (!this.alive) return;
+    try {
+      const frame = WebSocketFrame.build(Buffer.alloc(0), 0x0a);
+      this.socket.write(frame);
+    } catch {
+      this.alive = false;
+    }
+  }
+
+  /**
+   * Close the connection
+   * @param {number} [code=1000]
+   * @param {string} [reason]
+   */
+  close(code = 1000, reason = '') {
+    if (!this.alive) return;
+    this.alive = false;
+    clearInterval(this._pingInterval);
+    try {
+      const payload = Buffer.alloc(2 + Buffer.byteLength(reason));
+      payload.writeUInt16BE(code, 0);
+      Buffer.from(reason).copy(payload, 2);
+      const frame = WebSocketFrame.build(payload, 0x08);
+      this.socket.write(frame);
+    } catch { /* ignore */ }
+    this.socket.end();
+    this.emit('close');
+  }
+}
+
+/**
+ * WebSocket Server that upgrades HTTP connections
+ */
+export class WebSocketServer extends EventEmitter {
+  constructor() {
+    super();
+    /** @type {Map<string, WebSocketConnection>} */
+    this.clients = new Map();
+    this._clientCounter = 0;
+  }
+
+  /**
+   * Handle HTTP upgrade request
+   * @param {import('http').IncomingMessage} req
+   * @param {import('net').Socket} socket
+   * @param {Buffer} head
+   */
+  handleUpgrade(req, socket, head) {
+    const key = req.headers['sec-websocket-key'];
+    if (!key) {
+      socket.destroy();
+      return;
+    }
+
+    const acceptKey = crypto
+      .createHash('sha1')
+      .update(key + '258EAFA5-E914-47DA-95CA-5AB5DC525AA5')
+      .digest('base64');
+
+    const response = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${acceptKey}`,
+      '',
+      '',
+    ].join('\r\n');
+
+    socket.write(response);
+
+    const id = `ws-${++this._clientCounter}-${Date.now()}`;
+    const conn = new WebSocketConnection(socket, id);
+    this.clients.set(id, conn);
+
+    conn.on('close', () => {
+      this.clients.delete(id);
+      this.emit('disconnect', conn);
+    });
+
+    conn.on('message', (msg) => {
+      try {
+        const parsed = JSON.parse(msg.toString());
+        this.emit('message', conn, parsed);
+        if (parsed.event) {
+          this.emit(parsed.event, conn, parsed.data, parsed);
+        }
+      } catch {
+        this.emit('raw', conn, msg);
+      }
+    });
+
+    this.emit('connection', conn);
+
+    // Process any buffered data
+    if (head && head.length > 0) {
+      socket.emit('data', head);
+    }
+  }
+
+  /**
+   * Broadcast to all connected clients
+   * @param {string} event
+   * @param {*} data
+   * @param {string} [excludeId] - Exclude a specific client
+   */
+  broadcast(event, data, excludeId) {
+    const msg = { event, data, timestamp: Date.now() };
+    for (const [id, conn] of this.clients) {
+      if (id !== excludeId && conn.alive) {
+        conn.send(msg);
+      }
+    }
+  }
+
+  /**
+   * Send to a specific client
+   * @param {string} clientId
+   * @param {string} event
+   * @param {*} data
+   */
+  sendTo(clientId, event, data) {
+    const conn = this.clients.get(clientId);
+    if (conn && conn.alive) {
+      conn.send({ event, data, timestamp: Date.now() });
+    }
+  }
+
+  /**
+   * Get connected client count
+   * @returns {number}
+   */
+  get clientCount() {
+    return this.clients.size;
+  }
+
+  /**
+   * Close all connections
+   */
+  closeAll() {
+    for (const conn of this.clients.values()) {
+      try {
+        // Remove error listeners to prevent uncaught exceptions
+        conn.socket.removeAllListeners('error');
+        conn.socket.on('error', () => {});
+        conn.alive = false;
+        clearInterval(conn._pingInterval);
+        conn.socket.end();
+      } catch { /* ignore cleanup errors */ }
+    }
+    this.clients.clear();
+  }
+}
+
+export default WebSocketServer;

package/src/core/context-packager.mjs

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Context packager - compresses and packages context for LLM.
+ * Deduplication, summarization, relevance scoring, and token estimation.
+ * @module core/context-packager
+ */
+
+/**
+ * Estimate token count (rough: 1 token ≈ 4 chars).
+ * @param {string} text
+ * @returns {number}
+ */
+export function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Package gathered context into minimal, focused form for LLM consumption.
+ * @param {Object} data - Gathered data from tools/sub-tasks
+ * @param {Object} [options]
+ * @param {number} [options.maxTokens=4000] - Max token budget
+ * @param {string} [options.query] - Original query for relevance scoring
+ * @returns {Object} Packaged context
+ */
+export function packageContext(data, options = {}) {
+  const { maxTokens = 4000, query = '' } = options;
+
+  if (!data) {
+    return { context: '', tokens: 0, items: 0, compressed: false };
+  }
+
+  // Collect all text items
+  let items = collectItems(data);
+
+  // Deduplicate
+  items = deduplicate(items);
+
+  // Score relevance if query provided
+  if (query) {
+    items = items.map(item => ({
+      ...item,
+      relevance: scoreRelevance(item.text, query),
+    }));
+    items.sort((a, b) => b.relevance - a.relevance);
+  }
+
+  // Fit within token budget
+  const result = [];
+  let totalTokens = 0;
+
+  for (const item of items) {
+    const itemTokens = estimateTokens(item.text);
+    if (totalTokens + itemTokens > maxTokens) {
+      // Try to fit a truncated version
+      const remaining = maxTokens - totalTokens;
+      if (remaining > 50) {
+        const truncated = item.text.substring(0, remaining * 4);
+        result.push({ ...item, text: truncated, truncated: true });
+        totalTokens += estimateTokens(truncated);
+      }
+      break;
+    }
+    result.push(item);
+    totalTokens += itemTokens;
+  }
+
+  // Build final context string
+  const context = result.map(item => {
+    if (item.source) return `[${item.source}] ${item.text}`;
+    return item.text;
+  }).join('\n\n');
+
+  return {
+    context,
+    tokens: estimateTokens(context),
+    items: result.length,
+    compressed: result.length < items.length,
+    totalAvailable: items.length,
+  };
+}
+
+/**
+ * Collect all text items from data.
+ * @param {*} data
+ * @returns {Object[]}
+ */
+function collectItems(data) {
+  const items = [];
+
+  if (typeof data === 'string') {
+    items.push({ text: data, source: '' });
+    return items;
+  }
+
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      items.push(...collectItems(item));
+    }
+    return items;
+  }
+
+  if (typeof data === 'object' && data !== null) {
+    // Handle search results
+    if (data.results && Array.isArray(data.results)) {
+      for (const result of data.results) {
+        items.push({
+          text: `${result.title || ''} ${result.snippet || result.text || ''}`.trim(),
+          source: result.source || result.url || '',
+        });
+      }
+      return items;
+    }
+
+    // Handle scraped content
+    if (data.text) {
+      items.push({ text: data.text, source: data.url || data.source || '' });
+      return items;
+    }
+
+    // Generic object
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === 'string' && value.length > 10) {
+        items.push({ text: `${key}: ${value}`, source: '' });
+      }
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Deduplicate text items.
+ * @param {Object[]} items
+ * @returns {Object[]}
+ */
+function deduplicate(items) {
+  const seen = new Set();
+  return items.filter(item => {
+    // Normalize for comparison
+    const normalized = item.text.toLowerCase().replace(/\s+/g, ' ').trim();
+    if (normalized.length < 20) return true; // Don't dedup very short items
+    const hash = normalized.substring(0, 100); // Use first 100 chars as fingerprint
+    if (seen.has(hash)) return false;
+    seen.add(hash);
+    return true;
+  });
+}
+
+/**
+ * Score relevance of text to a query.
+ * @param {string} text
+ * @param {string} query
+ * @returns {number} 0-1
+ */
+function scoreRelevance(text, query) {
+  const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+  const textLower = text.toLowerCase();
+
+  if (queryWords.length === 0) return 0.5;
+
+  let matches = 0;
+  for (const word of queryWords) {
+    if (textLower.includes(word)) matches++;
+  }
+
+  return matches / queryWords.length;
+}
+
+export default { packageContext, estimateTokens };