@omiron33/omi-neuron-web 0.1.0

package/dist/chunk-RQCGONPN.js

@@ -0,0 +1,937 @@
+import OpenAI from 'openai';
+import crypto from 'crypto';
+import { Pool } from 'pg';
+
+// src/core/events/event-bus.ts
+var EventBus = class {
+  subscribers = /* @__PURE__ */ new Map();
+  globalSubscribers = /* @__PURE__ */ new Set();
+  middleware = [];
+  history = [];
+  historyLimit = 200;
+  emit(event) {
+    void this.emitAsync(event);
+  }
+  async emitAsync(event) {
+    await this.runMiddleware(event, async () => {
+      this.recordEvent(event);
+      const handlers = this.subscribers.get(event.type);
+      if (handlers) {
+        for (const handler of handlers) {
+          await handler(event);
+        }
+      }
+      for (const handler of this.globalSubscribers) {
+        await handler(event);
+      }
+    });
+  }
+  subscribe(type, handler) {
+    if (!this.subscribers.has(type)) {
+      this.subscribers.set(type, /* @__PURE__ */ new Set());
+    }
+    this.subscribers.get(type).add(handler);
+    return {
+      unsubscribe: () => this.unsubscribe(type, handler)
+    };
+  }
+  subscribeMany(types, handler) {
+    types.forEach((type) => this.subscribe(type, handler));
+    return {
+      unsubscribe: () => types.forEach((type) => this.unsubscribe(type, handler))
+    };
+  }
+  subscribeAll(handler) {
+    this.globalSubscribers.add(handler);
+    return {
+      unsubscribe: () => {
+        this.globalSubscribers.delete(handler);
+      }
+    };
+  }
+  unsubscribe(type, handler) {
+    const handlers = this.subscribers.get(type);
+    if (!handlers) return;
+    handlers.delete(handler);
+    if (handlers.size === 0) {
+      this.subscribers.delete(type);
+    }
+  }
+  unsubscribeAll() {
+    this.subscribers.clear();
+    this.globalSubscribers.clear();
+  }
+  use(middleware) {
+    this.middleware.push(middleware);
+  }
+  getSubscriberCount(type) {
+    if (!type) {
+      let count = this.globalSubscribers.size;
+      for (const handlers of this.subscribers.values()) {
+        count += handlers.size;
+      }
+      return count;
+    }
+    return this.subscribers.get(type)?.size ?? 0;
+  }
+  getEventHistory(limit) {
+    if (!limit) return [...this.history];
+    return this.history.slice(-limit);
+  }
+  clearHistory() {
+    this.history = [];
+  }
+  recordEvent(event) {
+    this.history.push(event);
+    if (this.history.length > this.historyLimit) {
+      this.history.shift();
+    }
+  }
+  async runMiddleware(event, finalHandler) {
+    const stack = [...this.middleware];
+    let index = -1;
+    const runner = async () => {
+      index += 1;
+      if (index < stack.length) {
+        await stack[index](event, runner);
+      } else {
+        await finalHandler();
+      }
+    };
+    await runner();
+  }
+};
+var createEvent = (type, payload, source = "system") => ({
+  type,
+  payload,
+  source,
+  timestamp: /* @__PURE__ */ new Date()
+});
+var EmbeddingsService = class {
+  constructor(config, db) {
+    this.config = config;
+    this.db = db;
+    this.client = new OpenAI({ apiKey: config.openaiApiKey });
+  }
+  client;
+  async generateEmbedding(text) {
+    const response = await this.client.embeddings.create({
+      model: this.config.model,
+      input: text,
+      dimensions: this.config.dimensions
+    });
+    return response.data[0].embedding;
+  }
+  async generateBatchEmbeddings(texts) {
+    const response = await this.client.embeddings.create({
+      model: this.config.model,
+      input: texts,
+      dimensions: this.config.dimensions
+    });
+    return response.data.map((item) => item.embedding);
+  }
+  async embedNode(nodeId) {
+    const node = await this.db.queryOne(
+      "SELECT id, content, embedding, embedding_generated_at FROM nodes WHERE id = $1",
+      [nodeId]
+    );
+    if (!node) {
+      throw new Error(`Node not found: ${nodeId}`);
+    }
+    const cached = await this.getCachedEmbedding(nodeId);
+    if (cached) {
+      return {
+        nodeId,
+        embedding: cached,
+        model: this.config.model,
+        tokenCount: this.countTokens(node.content ?? ""),
+        cached: true
+      };
+    }
+    const text = node.content ?? "";
+    const embedding = await this.withRetry(() => this.generateEmbedding(text));
+    await this.cacheEmbedding(nodeId, embedding, this.config.model);
+    return {
+      nodeId,
+      embedding,
+      model: this.config.model,
+      tokenCount: this.countTokens(text),
+      cached: false
+    };
+  }
+  async embedNodes(nodeIds) {
+    const results = [];
+    const errors = [];
+    const batches = [];
+    for (let i = 0; i < nodeIds.length; i += this.config.batchSize) {
+      batches.push(nodeIds.slice(i, i + this.config.batchSize));
+    }
+    for (const batch of batches) {
+      try {
+        const nodes = await this.db.query(
+          "SELECT id, content FROM nodes WHERE id = ANY($1)",
+          [batch]
+        );
+        const texts = nodes.map((node) => node.content ?? "");
+        const embeddings = await this.withRetry(() => this.generateBatchEmbeddings(texts));
+        for (let idx = 0; idx < nodes.length; idx += 1) {
+          const node = nodes[idx];
+          const embedding = embeddings[idx];
+          await this.cacheEmbedding(node.id, embedding, this.config.model);
+          results.push({
+            nodeId: node.id,
+            embedding,
+            model: this.config.model,
+            tokenCount: this.countTokens(node.content ?? ""),
+            cached: false
+          });
+        }
+        await this.applyRateLimit();
+      } catch (error) {
+        batch.forEach((nodeId) => {
+          errors.push({ nodeId, error: error instanceof Error ? error.message : String(error) });
+        });
+      }
+    }
+    return { results, errors };
+  }
+  async getCachedEmbedding(nodeId) {
+    const row = await this.db.queryOne(
+      "SELECT embedding, embedding_generated_at, embedding_model FROM nodes WHERE id = $1",
+      [nodeId]
+    );
+    if (!row?.embedding) return null;
+    if (row.embedding_model !== this.config.model) return null;
+    if (!row.embedding_generated_at) return row.embedding;
+    const ageSeconds = (Date.now() - row.embedding_generated_at.getTime()) / 1e3;
+    if (ageSeconds > this.config.cacheTTL) return null;
+    return row.embedding;
+  }
+  async cacheEmbedding(nodeId, embedding, model) {
+    await this.db.execute(
+      "UPDATE nodes SET embedding = $1, embedding_model = $2, embedding_generated_at = NOW() WHERE id = $3",
+      [embedding, model, nodeId]
+    );
+  }
+  async invalidateCache(nodeIds) {
+    if (nodeIds?.length) {
+      await this.db.execute(
+        "UPDATE nodes SET embedding = NULL, embedding_model = NULL, embedding_generated_at = NULL WHERE id = ANY($1)",
+        [nodeIds]
+      );
+      return;
+    }
+    await this.db.execute(
+      "UPDATE nodes SET embedding = NULL, embedding_model = NULL, embedding_generated_at = NULL"
+    );
+  }
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  estimateCost(nodeCount) {
+    const tokens = nodeCount * 512;
+    const pricePerMillion = this.config.model === "text-embedding-3-large" ? 0.13 : this.config.model === "text-embedding-3-small" ? 0.02 : 0.1;
+    const cost = tokens / 1e6 * pricePerMillion;
+    return { tokens, cost };
+  }
+  async withRetry(fn) {
+    let attempt = 0;
+    while (attempt <= this.config.maxRetries) {
+      try {
+        return await fn();
+      } catch (error) {
+        attempt += 1;
+        if (attempt > this.config.maxRetries) {
+          throw error;
+        }
+        const delay = 500 * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw new Error("Exceeded retry attempts");
+  }
+  async applyRateLimit() {
+    const delayMs = Math.ceil(6e4 / this.config.rateLimit);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+};
+var cosineSimilarity = (a, b) => {
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  if (magA === 0 || magB === 0) return 0;
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+};
+var averageVector = (vectors) => {
+  const length = vectors[0]?.length ?? 0;
+  const sum = new Array(length).fill(0);
+  vectors.forEach((vector) => {
+    vector.forEach((value, idx) => {
+      sum[idx] += value;
+    });
+  });
+  return sum.map((value) => value / vectors.length);
+};
+var ClusteringEngine = class {
+  constructor(db, embeddings) {
+    this.db = db;
+    this.embeddings = embeddings;
+  }
+  async clusterNodes(config) {
+    const nodes = await this.fetchNodesWithEmbeddings();
+    if (nodes.length === 0) return { clusters: [], unassigned: [] };
+    let clusters = [];
+    if (config.algorithm === "dbscan") {
+      clusters = this.runDbscan(nodes, config);
+    } else {
+      clusters = this.runKmeans(nodes, config);
+    }
+    await this.persistClusters(clusters);
+    const assigned = new Set(clusters.flatMap((cluster) => cluster.nodeIds));
+    const unassigned = nodes.map((node) => node.id).filter((id) => !assigned.has(id));
+    return { clusters, unassigned };
+  }
+  async recluster(config) {
+    const { clusters } = await this.clusterNodes(config);
+    return clusters;
+  }
+  async assignToCluster(nodeId) {
+    const node = await this.db.queryOne(
+      "SELECT id, embedding FROM nodes WHERE id = $1",
+      [nodeId]
+    );
+    if (!node?.embedding) return null;
+    const best = await this.findBestCluster(node.embedding);
+    if (!best) return null;
+    await this.db.execute(
+      "INSERT INTO cluster_memberships (node_id, cluster_id, similarity_score, is_primary) VALUES ($1, $2, $3, true) ON CONFLICT (node_id, cluster_id) DO UPDATE SET similarity_score = $3, is_primary = true",
+      [nodeId, best.clusterId, best.similarity]
+    );
+    await this.db.execute("UPDATE nodes SET cluster_id = $1, cluster_similarity = $2 WHERE id = $3", [
+      best.clusterId,
+      best.similarity,
+      nodeId
+    ]);
+    return {
+      nodeId,
+      clusterId: best.clusterId,
+      similarityScore: best.similarity,
+      isPrimary: true,
+      assignedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async findBestCluster(embedding) {
+    const clusters = await this.db.query(
+      "SELECT id, centroid FROM clusters WHERE centroid IS NOT NULL"
+    );
+    let best = null;
+    clusters.forEach((cluster) => {
+      if (!cluster.centroid) return;
+      const similarity = cosineSimilarity(cluster.centroid, embedding);
+      if (!best || similarity > best.similarity) {
+        best = { clusterId: cluster.id, similarity };
+      }
+    });
+    return best;
+  }
+  async recomputeCentroid(clusterId) {
+    const rows = await this.db.query(
+      "SELECT n.embedding FROM nodes n JOIN cluster_memberships cm ON n.id = cm.node_id WHERE cm.cluster_id = $1",
+      [clusterId]
+    );
+    const vectors = rows.map((row) => row.embedding).filter(Boolean);
+    if (vectors.length === 0) return;
+    const centroid = averageVector(vectors);
+    await this.db.execute("UPDATE clusters SET centroid = $1, last_recomputed_at = NOW() WHERE id = $2", [
+      centroid,
+      clusterId
+    ]);
+  }
+  async recomputeAllCentroids() {
+    const clusters = await this.db.query("SELECT id FROM clusters");
+    for (const cluster of clusters) {
+      await this.recomputeCentroid(cluster.id);
+    }
+  }
+  async generateClusterLabel(clusterId) {
+    const rows = await this.db.query(
+      "SELECT n.label FROM nodes n JOIN cluster_memberships cm ON n.id = cm.node_id WHERE cm.cluster_id = $1 LIMIT 5",
+      [clusterId]
+    );
+    const label = rows.map((row) => row.label).join(", ");
+    await this.db.execute("UPDATE clusters SET label = $1 WHERE id = $2", [label, clusterId]);
+    return label;
+  }
+  async generateAllLabels() {
+    const clusters = await this.db.query("SELECT id FROM clusters");
+    for (const cluster of clusters) {
+      await this.generateClusterLabel(cluster.id);
+    }
+  }
+  calculateSilhouetteScore(clusters) {
+    if (clusters.length === 0) return 0;
+    return clusters.reduce((acc, cluster) => acc + cluster.cohesion, 0) / clusters.length;
+  }
+  calculateCohesion(cluster) {
+    return cluster.cohesion;
+  }
+  async fetchNodesWithEmbeddings() {
+    const nodes = await this.db.query(
+      "SELECT * FROM nodes WHERE embedding IS NOT NULL"
+    );
+    return nodes;
+  }
+  runKmeans(nodes, config) {
+    const k = Math.max(1, config.clusterCount ?? 3);
+    const centroids = [];
+    const initialNodes = [...nodes].sort(() => Math.random() - 0.5).slice(0, k);
+    initialNodes.forEach((node) => centroids.push([...node.embedding]));
+    let assignments = /* @__PURE__ */ new Map();
+    for (let iteration = 0; iteration < 10; iteration += 1) {
+      assignments = /* @__PURE__ */ new Map();
+      nodes.forEach((node) => {
+        let bestIndex = 0;
+        let bestScore = -Infinity;
+        centroids.forEach((centroid, idx) => {
+          const score = cosineSimilarity(node.embedding, centroid);
+          if (score > bestScore) {
+            bestScore = score;
+            bestIndex = idx;
+          }
+        });
+        assignments.set(node.id, bestIndex);
+      });
+      for (let i = 0; i < k; i += 1) {
+        const members = nodes.filter((node) => assignments.get(node.id) === i);
+        if (members.length === 0) continue;
+        centroids[i] = averageVector(members.map((node) => node.embedding));
+      }
+    }
+    const clusters = [];
+    for (let i = 0; i < k; i += 1) {
+      const members = nodes.filter((node) => assignments.get(node.id) === i);
+      if (members.length === 0) continue;
+      const centroid = centroids[i];
+      const similarities = members.map((node) => cosineSimilarity(node.embedding, centroid));
+      const avgSimilarity = similarities.reduce((acc, val) => acc + val, 0) / similarities.length;
+      clusters.push({
+        clusterId: crypto.randomUUID(),
+        label: members.map((node) => node.label).slice(0, 3).join(", "),
+        nodeIds: members.map((node) => node.id),
+        centroid,
+        avgSimilarity,
+        cohesion: avgSimilarity
+      });
+    }
+    return clusters;
+  }
+  runDbscan(nodes, config) {
+    const epsilon = config.similarityThreshold ?? 0.75;
+    const minSamples = config.minSamples ?? 2;
+    const visited = /* @__PURE__ */ new Set();
+    const clusters = [];
+    for (const node of nodes) {
+      if (visited.has(node.id)) continue;
+      visited.add(node.id);
+      const neighbors = this.findNeighbors(nodes, node, epsilon);
+      if (neighbors.length < minSamples) {
+        continue;
+      }
+      const clusterMembers = /* @__PURE__ */ new Set([node.id, ...neighbors.map((n) => n.id)]);
+      let idx = 0;
+      const neighborList = [...neighbors];
+      while (idx < neighborList.length) {
+        const neighbor = neighborList[idx];
+        if (!visited.has(neighbor.id)) {
+          visited.add(neighbor.id);
+          const neighborNeighbors = this.findNeighbors(nodes, neighbor, epsilon);
+          if (neighborNeighbors.length >= minSamples) {
+            neighborNeighbors.forEach((n) => {
+              if (!clusterMembers.has(n.id)) {
+                clusterMembers.add(n.id);
+                neighborList.push(n);
+              }
+            });
+          }
+        }
+        idx += 1;
+      }
+      const members = nodes.filter((n) => clusterMembers.has(n.id));
+      const centroid = averageVector(members.map((member) => member.embedding));
+      const similarities = members.map((member) => cosineSimilarity(member.embedding, centroid));
+      const avgSimilarity = similarities.reduce((acc, val) => acc + val, 0) / similarities.length;
+      clusters.push({
+        clusterId: crypto.randomUUID(),
+        label: members.map((member) => member.label).slice(0, 3).join(", "),
+        nodeIds: members.map((member) => member.id),
+        centroid,
+        avgSimilarity,
+        cohesion: avgSimilarity
+      });
+    }
+    return clusters;
+  }
+  findNeighbors(nodes, node, threshold) {
+    return nodes.filter((candidate) => {
+      if (candidate.id === node.id) return false;
+      return cosineSimilarity(candidate.embedding, node.embedding) >= threshold;
+    });
+  }
+  async persistClusters(clusters) {
+    await this.db.transaction(async (client) => {
+      await client.query("DELETE FROM cluster_memberships");
+      await client.query("DELETE FROM clusters");
+      for (const cluster of clusters) {
+        await client.query(
+          "INSERT INTO clusters (id, label, centroid, member_count, avg_similarity, cohesion, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW())",
+          [
+            cluster.clusterId,
+            cluster.label,
+            cluster.centroid,
+            cluster.nodeIds.length,
+            cluster.avgSimilarity,
+            cluster.cohesion
+          ]
+        );
+        for (const nodeId of cluster.nodeIds) {
+          await client.query(
+            "INSERT INTO cluster_memberships (node_id, cluster_id, similarity_score, is_primary) VALUES ($1, $2, $3, true)",
+            [nodeId, cluster.clusterId, cluster.avgSimilarity]
+          );
+          await client.query("UPDATE nodes SET cluster_id = $1, cluster_similarity = $2 WHERE id = $3", [
+            cluster.clusterId,
+            cluster.avgSimilarity,
+            nodeId
+          ]);
+        }
+      }
+    });
+  }
+};
+var INFERENCE_PROMPT = `You are analyzing potential relationships between concepts in a knowledge graph.
+
+Node A:
+- Label: {nodeA.label}
+- Summary: {nodeA.summary}
+- Content: {nodeA.content}
+
+Node B:
+- Label: {nodeB.label}
+- Summary: {nodeB.summary}
+- Content: {nodeB.content}
+
+Determine if there is a meaningful relationship between these nodes.
+
+Respond in JSON:
+{
+  "hasRelationship": boolean,
+  "relationshipType": "related_to" | "derives_from" | "contradicts" | "supports" | "references" | "part_of" | "leads_to" | "similar_to",
+  "confidence": 0.0-1.0,
+  "reasoning": "Brief explanation",
+  "evidence": ["Specific quote or fact supporting this"]
+}
+`;
+var RelationshipEngine = class {
+  constructor(db, config) {
+    this.db = db;
+    this.config = config;
+    this.client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY ?? "" });
+  }
+  client;
+  async inferForNode(nodeId) {
+    const candidates = await this.findCandidates(nodeId);
+    const inferred = [];
+    for (const candidate of candidates.slice(0, this.config.maxPerNode)) {
+      const inference = await this.inferPair(nodeId, candidate.nodeId);
+      if (inference && inference.confidence >= this.config.minConfidence) {
+        inferred.push(inference);
+      }
+      await this.applyRateLimit();
+    }
+    return inferred;
+  }
+  async inferForNodes(nodeIds) {
+    const inferred = [];
+    const errors = [];
+    for (const nodeId of nodeIds) {
+      try {
+        const results = await this.inferForNode(nodeId);
+        inferred.push(...results);
+      } catch (error) {
+        errors.push({ nodeId, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    return { inferred, errors };
+  }
+  async inferAll() {
+    const nodes = await this.db.query("SELECT id FROM nodes");
+    const result = await this.inferForNodes(nodes.map((node) => node.id));
+    return result.inferred;
+  }
+  async findCandidates(nodeId) {
+    const rows = await this.db.query(
+      `SELECT id, 1 - (embedding <=> (SELECT embedding FROM nodes WHERE id = $1)) as similarity
+       FROM nodes
+       WHERE embedding IS NOT NULL AND id != $1
+       ORDER BY embedding <=> (SELECT embedding FROM nodes WHERE id = $1)
+       LIMIT $2`,
+      [nodeId, this.config.maxPerNode * 3]
+    );
+    return rows.filter((row) => row.similarity >= this.config.similarityThreshold).map((row) => ({ nodeId: row.id, similarity: row.similarity }));
+  }
+  async validateRelationship(rel) {
+    return rel.confidence >= this.config.minConfidence;
+  }
+  async createEdgesFromInferences(inferences, autoApprove = true) {
+    const created = [];
+    if (!autoApprove) return created;
+    for (const inference of inferences) {
+      const rows = await this.db.query(
+        `INSERT INTO edges (from_node_id, to_node_id, relationship_type, strength, confidence, evidence, source, source_model)
+         VALUES ($1, $2, $3, $4, $5, $6, 'ai_inferred', $7)
+         ON CONFLICT (from_node_id, to_node_id, relationship_type) DO NOTHING
+         RETURNING *`,
+        [
+          inference.fromNodeId,
+          inference.toNodeId,
+          inference.relationshipType,
+          inference.confidence,
+          inference.confidence,
+          JSON.stringify(inference.evidence),
+          this.config.model
+        ]
+      );
+      if (rows[0]) {
+        created.push(rows[0]);
+      }
+    }
+    return created;
+  }
+  async inferPair(fromNodeId, toNodeId) {
+    const [nodeA, nodeB] = await Promise.all([
+      this.db.queryOne(
+        "SELECT id, label, summary, content FROM nodes WHERE id = $1",
+        [fromNodeId]
+      ),
+      this.db.queryOne(
+        "SELECT id, label, summary, content FROM nodes WHERE id = $1",
+        [toNodeId]
+      )
+    ]);
+    if (!nodeA || !nodeB) return null;
+    const prompt = INFERENCE_PROMPT.replace("{nodeA.label}", nodeA.label).replace("{nodeA.summary}", nodeA.summary ?? "").replace("{nodeA.content}", nodeA.content ?? "").replace("{nodeB.label}", nodeB.label).replace("{nodeB.summary}", nodeB.summary ?? "").replace("{nodeB.content}", nodeB.content ?? "");
+    const response = await this.client.chat.completions.create({
+      model: this.config.model,
+      messages: [{ role: "user", content: prompt }],
+      response_format: { type: "json_object" }
+    });
+    const content = response.choices[0]?.message?.content;
+    if (!content) return null;
+    const parsed = JSON.parse(content);
+    if (!parsed.hasRelationship) return null;
+    return {
+      fromNodeId,
+      toNodeId,
+      relationshipType: parsed.relationshipType ?? "related_to",
+      confidence: parsed.confidence ?? 0,
+      reasoning: parsed.reasoning ?? "",
+      evidence: (parsed.evidence ?? []).map((text) => ({ type: "text", content: text }))
+    };
+  }
+  async applyRateLimit() {
+    const delayMs = Math.ceil(6e4 / this.config.rateLimit);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+};
+
+// src/core/analysis/pipeline.ts
+var AnalysisPipeline = class {
+  constructor(db, embeddings, clustering, relationships, events) {
+    this.db = db;
+    this.embeddings = embeddings;
+    this.clustering = clustering;
+    this.relationships = relationships;
+    this.events = events;
+  }
+  activeJobs = /* @__PURE__ */ new Map();
+  async runFull(options = {}) {
+    const job = await this.createJob("full_analysis", options);
+    try {
+      if (!options.skipEmbeddings) {
+        await this.runEmbeddingsStage(job, options);
+      }
+      if (!options.skipClustering) {
+        await this.runClusteringStage(job, options);
+      }
+      if (!options.skipRelationships) {
+        await this.runRelationshipsStage(job, options);
+      }
+      return await this.completeJob(job.id);
+    } catch (error) {
+      return await this.failJob(job.id, error);
+    }
+  }
+  async runEmbeddings(options = {}) {
+    const job = await this.createJob("embedding", options);
+    try {
+      await this.runEmbeddingsStage(job, options);
+      return await this.completeJob(job.id);
+    } catch (error) {
+      return await this.failJob(job.id, error);
+    }
+  }
+  async runClustering(options = {}) {
+    const job = await this.createJob("clustering", options);
+    try {
+      await this.runClusteringStage(job, options);
+      return await this.completeJob(job.id);
+    } catch (error) {
+      return await this.failJob(job.id, error);
+    }
+  }
+  async runRelationships(options = {}) {
+    const job = await this.createJob("relationship_inference", options);
+    try {
+      await this.runRelationshipsStage(job, options);
+      return await this.completeJob(job.id);
+    } catch (error) {
+      return await this.failJob(job.id, error);
+    }
+  }
+  async getJob(jobId) {
+    const row = await this.db.queryOne("SELECT * FROM analysis_runs WHERE id = $1", [jobId]);
+    return row ?? null;
+  }
+  async listJobs(options) {
+    const where = options?.status ? "WHERE status = $1" : "";
+    const limit = options?.limit ? `LIMIT ${options.limit}` : "";
+    const rows = await this.db.query(
+      `SELECT * FROM analysis_runs ${where} ORDER BY created_at DESC ${limit}`,
+      options?.status ? [options.status] : []
+    );
+    return rows;
+  }
+  async cancelJob(jobId) {
+    const controller = this.activeJobs.get(jobId);
+    if (!controller) return false;
+    controller.abort();
+    await this.db.execute("UPDATE analysis_runs SET status = $1 WHERE id = $2", [
+      "cancelled",
+      jobId
+    ]);
+    return true;
+  }
+  getActiveJobs() {
+    return [];
+  }
+  isRunning() {
+    return this.activeJobs.size > 0;
+  }
+  async runEmbeddingsStage(job, options) {
+    const nodeIds = await this.resolveNodeIds(options.nodeIds, options.forceRecompute);
+    const { results, errors } = await this.embeddings.embedNodes(nodeIds);
+    await this.updateJobResults(job.id, {
+      embeddingsGenerated: results.length,
+      errors
+    });
+    options.onProgress?.({
+      stage: "embeddings",
+      progress: 100,
+      currentItem: "complete",
+      itemsProcessed: results.length,
+      totalItems: nodeIds.length
+    });
+  }
+  async runClusteringStage(job, options) {
+    const clusterCount = options.clusterCount;
+    const algorithm = options.clusteringAlgorithm ?? "kmeans";
+    const result = await this.clustering.clusterNodes({
+      algorithm,
+      clusterCount,
+      similarityThreshold: options.relationshipThreshold
+    });
+    await this.updateJobResults(job.id, {
+      clustersCreated: result.clusters.length
+    });
+    options.onProgress?.({
+      stage: "clustering",
+      progress: 100,
+      currentItem: "complete",
+      itemsProcessed: result.clusters.length,
+      totalItems: result.clusters.length
+    });
+  }
+  async runRelationshipsStage(job, options) {
+    const nodeIds = options.nodeIds ?? await this.resolveNodeIds();
+    const { inferred, errors } = await this.relationships.inferForNodes(nodeIds);
+    await this.relationships.createEdgesFromInferences(inferred, true);
+    await this.updateJobResults(job.id, {
+      relationshipsInferred: inferred.length,
+      errors
+    });
+    options.onProgress?.({
+      stage: "relationships",
+      progress: 100,
+      currentItem: "complete",
+      itemsProcessed: inferred.length,
+      totalItems: inferred.length
+    });
+  }
+  async createJob(runType, options) {
+    const controller = new AbortController();
+    const row = await this.db.queryOne(
+      `INSERT INTO analysis_runs (run_type, input_params, status, progress, started_at)
+       VALUES ($1, $2, 'running', 0, NOW())
+       RETURNING *`,
+      [runType, options]
+    );
+    if (!row) throw new Error("Failed to create analysis job");
+    this.activeJobs.set(row.id, controller);
+    return row;
+  }
+  async completeJob(jobId) {
+    const row = await this.db.queryOne(
+      `UPDATE analysis_runs
+       SET status = 'completed', progress = 100, completed_at = NOW(), duration_ms = EXTRACT(EPOCH FROM (NOW() - started_at)) * 1000
+       WHERE id = $1
+       RETURNING *`,
+      [jobId]
+    );
+    this.activeJobs.delete(jobId);
+    return row;
+  }
+  async failJob(jobId, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : void 0;
+    const row = await this.db.queryOne(
+      `UPDATE analysis_runs
+       SET status = 'failed', error_message = $2, error_stack = $3, completed_at = NOW(), duration_ms = EXTRACT(EPOCH FROM (NOW() - started_at)) * 1000
+       WHERE id = $1
+       RETURNING *`,
+      [jobId, message, stack]
+    );
+    this.activeJobs.delete(jobId);
+    return row;
+  }
+  async updateJobResults(jobId, updates) {
+    const row = await this.db.queryOne(
+      "SELECT results FROM analysis_runs WHERE id = $1",
+      [jobId]
+    );
+    const current = row?.results ?? {
+      nodesProcessed: 0,
+      embeddingsGenerated: 0,
+      clustersCreated: 0,
+      relationshipsInferred: 0,
+      errors: []
+    };
+    const next = { ...current, ...updates };
+    await this.db.execute("UPDATE analysis_runs SET results = $1 WHERE id = $2", [next, jobId]);
+  }
+  async resolveNodeIds(nodeIds, forceRecompute = false) {
+    if (nodeIds?.length) return nodeIds;
+    if (forceRecompute) {
+      const rows2 = await this.db.query("SELECT id FROM nodes");
+      return rows2.map((row) => row.id);
+    }
+    const rows = await this.db.query("SELECT id FROM nodes WHERE embedding IS NULL");
+    return rows.map((row) => row.id);
+  }
+};
+var Database = class {
+  pool;
+  slowQueryThresholdMs;
+  constructor(config) {
+    const poolConfig = {
+      connectionString: config.connectionString ?? this.buildConnectionString(config),
+      ssl: config.ssl,
+      min: config.pool?.min,
+      max: config.pool?.max,
+      idleTimeoutMillis: config.pool?.idleTimeoutMs,
+      connectionTimeoutMillis: config.pool?.connectionTimeoutMs
+    };
+    this.pool = new Pool(poolConfig);
+    this.slowQueryThresholdMs = config.slowQueryThresholdMs;
+  }
+  async connect() {
+    const client = await this.pool.connect();
+    client.release();
+  }
+  async disconnect() {
+    await this.pool.end();
+  }
+  async isConnected() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async query(sql, params = []) {
+    const start = Date.now();
+    const result = await this.pool.query(sql, params);
+    this.logSlowQuery(sql, Date.now() - start);
+    return result.rows;
+  }
+  async queryOne(sql, params = []) {
+    const rows = await this.query(sql, params);
+    return rows[0] ?? null;
+  }
+  async execute(sql, params = []) {
+    const start = Date.now();
+    const result = await this.pool.query(sql, params);
+    this.logSlowQuery(sql, Date.now() - start);
+    return result.rowCount ?? 0;
+  }
+  async transaction(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async tableExists(tableName) {
+    const result = await this.queryOne(
+      "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1) as exists",
+      [tableName]
+    );
+    return result?.exists ?? false;
+  }
+  async getPoolStats() {
+    return {
+      totalCount: this.pool.totalCount,
+      idleCount: this.pool.idleCount,
+      waitingCount: this.pool.waitingCount
+    };
+  }
+  buildConnectionString(config) {
+    if (config.host && config.port && config.user && config.database) {
+      const password = config.password ? `:${config.password}` : "";
+      return `postgresql://${config.user}${password}@${config.host}:${config.port}/${config.database}`;
+    }
+    return void 0;
+  }
+  logSlowQuery(sql, durationMs) {
+    if (!this.slowQueryThresholdMs || durationMs < this.slowQueryThresholdMs) {
+      return;
+    }
+    console.warn(`[omi-neuron] Slow query (${durationMs}ms): ${sql}`);
+  }
+};
+
+export { AnalysisPipeline, ClusteringEngine, Database, EmbeddingsService, EventBus, RelationshipEngine, createEvent };
+//# sourceMappingURL=chunk-RQCGONPN.js.map
+//# sourceMappingURL=chunk-RQCGONPN.js.map