prepia 1.0.0

package/src/models/provider.mjs

@@ -0,0 +1,192 @@
+/**
+ * @fileoverview LLM provider abstraction layer.
+ * Unified interface for OpenAI, Anthropic, and Gemini style APIs.
+ * @module models/provider
+ */
+
+/**
+ * @typedef {Object} LLMRequest
+ * @property {string} prompt - The prompt text
+ * @property {string} [system] - System message
+ * @property {number} [maxTokens=2048] - Max tokens to generate
+ * @property {number} [temperature=0.7] - Temperature
+ * @property {boolean} [stream=false] - Enable streaming
+ */
+
+/**
+ * @typedef {Object} LLMResponse
+ * @property {string} content - Generated text
+ * @property {Object} usage - Token usage { prompt, completion, total }
+ * @property {string} model - Model used
+ * @property {string} provider - Provider name
+ * @property {number} latency - Response time in ms
+ */
+
+/**
+ * Format a request for the OpenAI API format.
+ * @param {LLMRequest} request
+ * @param {Object} config - Provider config
+ * @returns {Object}
+ */
+export function formatOpenAI(request, config) {
+  const messages = [];
+  if (request.system) {
+    messages.push({ role: 'system', content: request.system });
+  }
+  messages.push({ role: 'user', content: request.prompt });
+
+  return {
+    url: `${config.baseUrl || 'https://api.openai.com'}/v1/chat/completions`,
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${config.apiKey}`,
+    },
+    body: {
+      model: config.model || 'gpt-4o-mini',
+      messages,
+      max_tokens: request.maxTokens ?? 2048,
+      temperature: request.temperature ?? 0.7,
+      stream: request.stream ?? false,
+    },
+  };
+}
+
+/**
+ * Format a request for the Anthropic API format.
+ * @param {LLMRequest} request
+ * @param {Object} config
+ * @returns {Object}
+ */
+export function formatAnthropic(request, config) {
+  return {
+    url: `${config.baseUrl || 'https://api.anthropic.com'}/v1/messages`,
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': config.apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: {
+      model: config.model || 'claude-3-5-sonnet-20241022',
+      max_tokens: request.maxTokens ?? 2048,
+      messages: [{ role: 'user', content: request.prompt }],
+      ...(request.system ? { system: request.system } : {}),
+    },
+  };
+}
+
+/**
+ * Format a request for the Gemini API format.
+ * @param {LLMRequest} request
+ * @param {Object} config
+ * @returns {Object}
+ */
+export function formatGemini(request, config) {
+  const contents = [];
+  if (request.system) {
+    contents.push({ role: 'user', parts: [{ text: request.system }] });
+    contents.push({ role: 'model', parts: [{ text: 'Understood.' }] });
+  }
+  contents.push({ role: 'user', parts: [{ text: request.prompt }] });
+
+  return {
+    url: `${config.baseUrl || 'https://generativelanguage.googleapis.com'}/v1beta/models/${config.model || 'gemini-pro'}:generateContent?key=${config.apiKey}`,
+    headers: { 'Content-Type': 'application/json' },
+    body: {
+      contents,
+      generationConfig: {
+        maxOutputTokens: request.maxTokens ?? 2048,
+        temperature: request.temperature ?? 0.7,
+      },
+    },
+  };
+}
+
+/**
+ * Parse an OpenAI-format response.
+ * @param {Object} response - Raw API response
+ * @returns {Partial<LLMResponse>}
+ */
+export function parseOpenAI(response) {
+  const choice = response.choices?.[0];
+  return {
+    content: choice?.message?.content || '',
+    usage: {
+      prompt: response.usage?.prompt_tokens ?? 0,
+      completion: response.usage?.completion_tokens ?? 0,
+      total: response.usage?.total_tokens ?? 0,
+    },
+    model: response.model || '',
+  };
+}
+
+/**
+ * Parse an Anthropic-format response.
+ * @param {Object} response
+ * @returns {Partial<LLMResponse>}
+ */
+export function parseAnthropic(response) {
+  return {
+    content: response.content?.[0]?.text || '',
+    usage: {
+      prompt: response.usage?.input_tokens ?? 0,
+      completion: response.usage?.output_tokens ?? 0,
+      total: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
+    },
+    model: response.model || '',
+  };
+}
+
+/**
+ * Parse a Gemini-format response.
+ * @param {Object} response
+ * @returns {Partial<LLMResponse>}
+ */
+export function parseGemini(response) {
+  const candidate = response.candidates?.[0];
+  return {
+    content: candidate?.content?.parts?.[0]?.text || '',
+    usage: {
+      prompt: response.usageMetadata?.promptTokenCount ?? 0,
+      completion: response.usageMetadata?.candidatesTokenCount ?? 0,
+      total: response.usageMetadata?.totalTokenCount ?? 0,
+    },
+    model: '',
+  };
+}
+
+/**
+ * Format a request for a given provider type.
+ * @param {string} type - Provider type (openai, anthropic, gemini)
+ * @param {LLMRequest} request
+ * @param {Object} config
+ * @returns {Object}
+ */
+export function formatRequest(type, request, config) {
+  switch (type) {
+    case 'openai': return formatOpenAI(request, config);
+    case 'anthropic': return formatAnthropic(request, config);
+    case 'gemini': return formatGemini(request, config);
+    default: throw new Error(`Unknown provider type: ${type}`);
+  }
+}
+
+/**
+ * Parse a response from a given provider type.
+ * @param {string} type
+ * @param {Object} response
+ * @returns {Partial<LLMResponse>}
+ */
+export function parseResponse(type, response) {
+  switch (type) {
+    case 'openai': return parseOpenAI(response);
+    case 'anthropic': return parseAnthropic(response);
+    case 'gemini': return parseGemini(response);
+    default: throw new Error(`Unknown provider type: ${type}`);
+  }
+}
+
+export default {
+  formatOpenAI, formatAnthropic, formatGemini,
+  parseOpenAI, parseAnthropic, parseGemini,
+  formatRequest, parseResponse,
+};

package/src/models/router.mjs

@@ -0,0 +1,156 @@
+/**
+ * @fileoverview Multi-LLM routing with fallback and priority-based selection.
+ * @module models/router
+ */
+
+import { EventEmitter } from 'node:events';
+import { formatRequest, parseResponse } from './provider.mjs';
+
+/**
+ * @typedef {Object} ProviderConfig
+ * @property {string} name - Provider name
+ * @property {string} type - Provider type (openai, anthropic, gemini)
+ * @property {string} apiKey - API key
+ * @property {string} [model] - Model name
+ * @property {string} [baseUrl] - Base URL override
+ * @property {number} [priority=0] - Higher = preferred
+ * @property {number} [maxRetries=2] - Max retries before fallback
+ */
+
+export class ModelRouter extends EventEmitter {
+  /**
+   * @param {Object} [options]
+   * @param {ProviderConfig[]} [options.providers] - Available providers
+   */
+  constructor(options = {}) {
+    super();
+    /** @type {ProviderConfig[]} */
+    this._providers = (options.providers || []).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    this._usage = new Map();
+  }
+
+  /**
+   * Add a provider.
+   * @param {ProviderConfig} config
+   */
+  addProvider(config) {
+    this._providers.push(config);
+    this._providers.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  }
+
+  /**
+   * Remove a provider.
+   * @param {string} name
+   * @returns {boolean}
+   */
+  removeProvider(name) {
+    const idx = this._providers.findIndex(p => p.name === name);
+    if (idx >= 0) {
+      this._providers.splice(idx, 1);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get list of provider names.
+   * @returns {string[]}
+   */
+  listProviders() {
+    return this._providers.map(p => p.name);
+  }
+
+  /**
+   * Send a request to the best available provider with fallback.
+   * @param {import('./provider.mjs').LLMRequest} request
+   * @param {Object} [options]
+   * @param {string} [options.preferredProvider] - Force a specific provider
+   * @returns {Promise<import('./provider.mjs').LLMResponse>}
+   */
+  async send(request, options = {}) {
+    const providers = options.preferredProvider
+      ? this._providers.filter(p => p.name === options.preferredProvider).concat(this._providers.filter(p => p.name !== options.preferredProvider))
+      : [...this._providers];
+
+    if (providers.length === 0) {
+      throw new Error('No providers configured');
+    }
+
+    let lastError;
+    for (const provider of providers) {
+      try {
+        const result = await this._sendToProvider(provider, request);
+        this.emit('provider:success', { provider: provider.name, usage: result.usage });
+        return result;
+      } catch (err) {
+        lastError = err;
+        this.emit('provider:error', { provider: provider.name, error: err.message });
+        continue;
+      }
+    }
+
+    throw new Error(`All providers failed. Last error: ${lastError?.message}`);
+  }
+
+  /**
+   * Send a request to a specific provider.
+   * @param {ProviderConfig} provider
+   * @param {import('./provider.mjs').LLMRequest} request
+   * @returns {Promise<import('./provider.mjs').LLMResponse>}
+   * @private
+   */
+  async _sendToProvider(provider, request) {
+    const start = Date.now();
+    const formatted = formatRequest(provider.type, request, provider);
+
+    const response = await fetch(formatted.url, {
+      method: 'POST',
+      headers: formatted.headers,
+      body: JSON.stringify(formatted.body),
+      signal: AbortSignal.timeout(60000),
+    });
+
+    if (!response.ok) {
+      const errBody = await response.text().catch(() => 'Unknown error');
+      throw new Error(`${provider.name} API error ${response.status}: ${errBody}`);
+    }
+
+    const data = await response.json();
+    const parsed = parseResponse(provider.type, data);
+
+    // Track usage
+    const prev = this._usage.get(provider.name) || { requests: 0, tokens: 0 };
+    this._usage.set(provider.name, {
+      requests: prev.requests + 1,
+      tokens: prev.tokens + (parsed.usage?.total ?? 0),
+    });
+
+    return {
+      ...parsed,
+      provider: provider.name,
+      latency: Date.now() - start,
+    };
+  }
+
+  /**
+   * Get usage stats for all providers.
+   * @returns {Object}
+   */
+  getUsage() {
+    const result = {};
+    for (const [name, usage] of this._usage) {
+      result[name] = { ...usage };
+    }
+    return result;
+  }
+
+  /**
+   * Get the number of configured providers.
+   * @returns {number}
+   */
+  get providerCount() {
+    return this._providers.length;
+  }
+}
+
+export default ModelRouter;

package/src/morph/optimizer.mjs

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Self-evolving workflow optimization.
+ * @module morph/optimizer
+ */
+
+export class Optimizer {
+  constructor() {
+    /** @type {Map<string, Object>} Workflow performance data */
+    this._workflows = new Map();
+  }
+
+  /**
+   * Record a workflow execution.
+   * @param {string} workflowId - Workflow identifier
+   * @param {Object} result - Execution result
+   * @param {boolean} result.success - Whether it succeeded
+   * @param {number} result.duration - Duration in ms
+   * @param {number} [result.tokensUsed=0] - Tokens consumed
+   * @param {Object} [result.params] - Parameters used
+   */
+  record(workflowId, result) {
+    const existing = this._workflows.get(workflowId) || {
+      id: workflowId,
+      runs: 0,
+      successes: 0,
+      totalDuration: 0,
+      totalTokens: 0,
+      avgDuration: 0,
+      successRate: 0,
+      lastRun: null,
+    };
+
+    existing.runs++;
+    if (result.success) existing.successes++;
+    existing.totalDuration += result.duration || 0;
+    existing.totalTokens += result.tokensUsed || 0;
+    existing.avgDuration = existing.totalDuration / existing.runs;
+    existing.successRate = existing.successes / existing.runs;
+    existing.lastRun = Date.now();
+
+    this._workflows.set(workflowId, existing);
+  }
+
+  /**
+   * Get optimization suggestions for a workflow.
+   * @param {string} workflowId
+   * @returns {Object[]}
+   */
+  getOptimizations(workflowId) {
+    const data = this._workflows.get(workflowId);
+    if (!data || data.runs < 3) return [];
+
+    const suggestions = [];
+
+    if (data.successRate < 0.8) {
+      suggestions.push({
+        type: 'reliability',
+        priority: 'high',
+        message: `Low success rate (${(data.successRate * 100).toFixed(0)}%). Consider simplifying the workflow or adding error handling.`,
+      });
+    }
+
+    if (data.avgDuration > 30000) {
+      suggestions.push({
+        type: 'performance',
+        priority: 'medium',
+        message: `Average duration is ${(data.avgDuration / 1000).toFixed(1)}s. Consider caching or parallel execution.`,
+      });
+    }
+
+    if (data.totalTokens > 100000) {
+      suggestions.push({
+        type: 'cost',
+        priority: 'medium',
+        message: `High token usage (${data.totalTokens}). Consider context compression or local processing.`,
+      });
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Identify bottlenecks across all workflows.
+   * @returns {Object[]}
+   */
+  identifyBottlenecks() {
+    const bottlenecks = [];
+
+    for (const data of this._workflows.values()) {
+      if (data.runs < 2) continue;
+
+      if (data.avgDuration > 20000) {
+        bottlenecks.push({
+          workflowId: data.id,
+          issue: 'slow_execution',
+          avgDuration: data.avgDuration,
+          severity: data.avgDuration > 60000 ? 'critical' : 'warning',
+        });
+      }
+
+      if (data.successRate < 0.7) {
+        bottlenecks.push({
+          workflowId: data.id,
+          issue: 'low_success_rate',
+          successRate: data.successRate,
+          severity: data.successRate < 0.5 ? 'critical' : 'warning',
+        });
+      }
+    }
+
+    return bottlenecks.sort((a, b) => {
+      const severityOrder = { critical: 0, warning: 1 };
+      return (severityOrder[a.severity] ?? 2) - (severityOrder[b.severity] ?? 2);
+    });
+  }
+
+  /**
+   * Get all tracked workflows.
+   * @returns {Object[]}
+   */
+  getWorkflows() {
+    return Array.from(this._workflows.values());
+  }
+
+  /**
+   * Get stats for a specific workflow.
+   * @param {string} workflowId
+   * @returns {Object|undefined}
+   */
+  getStats(workflowId) {
+    return this._workflows.get(workflowId);
+  }
+
+  /**
+   * Clear all tracking data.
+   */
+  clear() {
+    this._workflows.clear();
+  }
+}
+
+export default Optimizer;

package/src/network/p2p.mjs

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview Distributed task sharing - PrepiNet P2P network.
+ * @module network/p2p
+ */
+
+import { EventEmitter } from 'node:events';
+import crypto from 'node:crypto';
+
+export class P2PNetwork extends EventEmitter {
+  /**
+   * @param {Object} [options]
+   * @param {string} [options.nodeId] - Unique node identifier
+   * @param {number} [options.port=0] - Listening port
+   */
+  constructor(options = {}) {
+    super();
+    this._nodeId = options.nodeId || crypto.randomUUID();
+    this._port = options.port ?? 0;
+    /** @type {Map<string, Object>} Known peers */
+    this._peers = new Map();
+    /** @type {Map<string, Object>} Shared cache entries */
+    this._sharedCache = new Map();
+    this._running = false;
+  }
+
+  /**
+   * Get this node's ID.
+   * @returns {string}
+   */
+  get nodeId() {
+    return this._nodeId;
+  }
+
+  /**
+   * Add a peer.
+   * @param {Object} peer
+   * @param {string} peer.id - Peer node ID
+   * @param {string} peer.host - Peer host
+   * @param {number} peer.port - Peer port
+   */
+  addPeer(peer) {
+    if (peer.id === this._nodeId) return;
+    this._peers.set(peer.id, {
+      ...peer,
+      lastSeen: Date.now(),
+      status: 'connected',
+    });
+    this.emit('peer:added', peer);
+  }
+
+  /**
+   * Remove a peer.
+   * @param {string} peerId
+   */
+  removePeer(peerId) {
+    this._peers.delete(peerId);
+    this.emit('peer:removed', { id: peerId });
+  }
+
+  /**
+   * Get all known peers.
+   * @returns {Object[]}
+   */
+  getPeers() {
+    return Array.from(this._peers.values());
+  }
+
+  /**
+   * Share a cache entry with the network.
+   * @param {string} key - Cache key
+   * @param {*} value - Cached value
+   * @param {number} [ttl=300000] - TTL in ms
+   */
+  shareCache(key, value, ttl = 300000) {
+    this._sharedCache.set(key, {
+      key,
+      value,
+      sharedAt: Date.now(),
+      expiresAt: Date.now() + ttl,
+      source: this._nodeId,
+    });
+    this.emit('cache:shared', { key });
+  }
+
+  /**
+   * Query the shared cache.
+   * @param {string} key
+   * @returns {*}
+   */
+  queryCache(key) {
+    const entry = this._sharedCache.get(key);
+    if (!entry) return undefined;
+    if (Date.now() > entry.expiresAt) {
+      this._sharedCache.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  /**
+   * Get the node count (including self).
+   * @returns {number}
+   */
+  get nodeCount() {
+    return this._peers.size + 1;
+  }
+
+  /**
+   * Get network stats.
+   * @returns {Object}
+   */
+  stats() {
+    return {
+      nodeId: this._nodeId,
+      peers: this._peers.size,
+      sharedEntries: this._sharedCache.size,
+      running: this._running,
+    };
+  }
+
+  /**
+   * Start the P2P network.
+   */
+  start() {
+    this._running = true;
+    this.emit('network:started', { nodeId: this._nodeId });
+  }
+
+  /**
+   * Stop the P2P network.
+   */
+  stop() {
+    this._running = false;
+    this.emit('network:stopped', { nodeId: this._nodeId });
+  }
+
+  /**
+   * Check if network is running.
+   * @returns {boolean}
+   */
+  get isRunning() {
+    return this._running;
+  }
+}
+
+export default P2PNetwork;