@omiron33/omi-neuron-web 0.1.0

package/dist/api/index.cjs

@@ -0,0 +1,943 @@
+'use strict';
+
+var chunkRTSFO7BW_cjs = require('../chunk-RTSFO7BW.cjs');
+var chunkCOO66N7H_cjs = require('../chunk-COO66N7H.cjs');
+
+// src/api/repositories/base.ts
+var BaseRepository = class {
+  constructor(db, tableName) {
+    this.db = db;
+    this.tableName = tableName;
+  }
+  async findById(id) {
+    const { sql, values } = chunkRTSFO7BW_cjs.buildSelect(this.tableName, "*", { id });
+    const rows = await this.db.query(sql, values);
+    return rows[0] ?? null;
+  }
+  async findAll(options) {
+    const { sql, values } = chunkRTSFO7BW_cjs.buildSelect(
+      this.tableName,
+      "*",
+      options?.where,
+      options
+    );
+    return this.db.query(sql, values);
+  }
+  async create(data) {
+    const { sql, values } = chunkRTSFO7BW_cjs.buildInsert(this.tableName, data);
+    const rows = await this.db.query(sql, values);
+    return rows[0];
+  }
+  async update(id, data) {
+    const { sql, values } = chunkRTSFO7BW_cjs.buildUpdate(this.tableName, data, { id });
+    const rows = await this.db.query(sql, values);
+    return rows[0] ?? null;
+  }
+  async delete(id) {
+    const { sql, values } = chunkRTSFO7BW_cjs.buildDelete(this.tableName, { id });
+    const count = await this.db.execute(sql, values);
+    return count > 0;
+  }
+  async count(where) {
+    const whereResult = chunkRTSFO7BW_cjs.buildWhereClause(where);
+    const sql = `SELECT COUNT(*)::int as count FROM ${this.tableName} ${whereResult.clause}`;
+    const rows = await this.db.query(sql, whereResult.values);
+    return Number(rows[0]?.count ?? 0);
+  }
+};
+
+// src/api/repositories/node-repository.ts
+var mapNodeRow = (row) => ({
+  id: row.id,
+  slug: row.slug,
+  label: row.label,
+  nodeType: row.node_type,
+  domain: row.domain,
+  summary: row.summary ?? null,
+  description: row.description ?? null,
+  content: row.content ?? null,
+  metadata: row.metadata ?? {},
+  tier: row.tier ?? void 0,
+  visualPriority: row.visual_priority ?? void 0,
+  positionOverride: row.position_override ?? null,
+  connectionCount: row.connection_count ?? 0,
+  inboundCount: row.inbound_count ?? 0,
+  outboundCount: row.outbound_count ?? 0,
+  analysisStatus: row.analysis_status ?? "pending",
+  analysisError: row.analysis_error ?? null,
+  embedding: row.embedding ?? null,
+  embeddingModel: row.embedding_model ?? null,
+  embeddingGeneratedAt: row.embedding_generated_at ?? null,
+  clusterId: row.cluster_id ?? null,
+  clusterSimilarity: row.cluster_similarity ?? null,
+  createdAt: row.created_at,
+  updatedAt: row.updated_at
+});
+var NodeRepository = class extends BaseRepository {
+  constructor(db) {
+    super(db, "nodes");
+  }
+  async findById(id) {
+    const row = await this.db.queryOne("SELECT * FROM nodes WHERE id = $1", [id]);
+    return row ? mapNodeRow(row) : null;
+  }
+  async findAll(options) {
+    const rows = await super.findAll(options);
+    return rows.map(mapNodeRow);
+  }
+  async findBySlug(slug) {
+    const row = await this.db.queryOne("SELECT * FROM nodes WHERE slug = $1", [slug]);
+    return row ? mapNodeRow(row) : null;
+  }
+  async findByDomain(domain) {
+    const rows = await this.db.query("SELECT * FROM nodes WHERE domain = $1", [domain]);
+    return rows.map(mapNodeRow);
+  }
+  async findByCluster(clusterId) {
+    const rows = await this.db.query("SELECT * FROM nodes WHERE cluster_id = $1", [clusterId]);
+    return rows.map(mapNodeRow);
+  }
+  async search(query) {
+    const rows = await this.db.query(
+      `SELECT * FROM nodes WHERE label ILIKE $1 OR summary ILIKE $1 OR content ILIKE $1`,
+      [`%${query}%`]
+    );
+    return rows.map(mapNodeRow);
+  }
+  async batchCreate(nodes) {
+    const created = [];
+    for (const node of nodes) {
+      const row = await this.db.queryOne(
+        `INSERT INTO nodes (slug, label, node_type, domain, summary, description, content, metadata, tier)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+         RETURNING *`,
+        [
+          node.slug,
+          node.label,
+          node.nodeType ?? "concept",
+          node.domain ?? "general",
+          node.summary ?? null,
+          node.description ?? null,
+          node.content ?? null,
+          node.metadata ?? {},
+          node.tier ?? null
+        ]
+      );
+      if (row) created.push(mapNodeRow(row));
+    }
+    return created;
+  }
+  async updateConnectionCounts(nodeId) {
+    const inbound = await this.db.queryOne(
+      "SELECT COUNT(*)::int as count FROM edges WHERE to_node_id = $1",
+      [nodeId]
+    );
+    const outbound = await this.db.queryOne(
+      "SELECT COUNT(*)::int as count FROM edges WHERE from_node_id = $1",
+      [nodeId]
+    );
+    const inboundCount = Number(inbound?.count ?? 0);
+    const outboundCount = Number(outbound?.count ?? 0);
+    await this.db.execute(
+      "UPDATE nodes SET inbound_count = $1, outbound_count = $2, connection_count = $3 WHERE id = $4",
+      [inboundCount, outboundCount, inboundCount + outboundCount, nodeId]
+    );
+  }
+};
+
+// src/api/routes/nodes.ts
+var createNodesRoutes = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  const repo = new NodeRepository(db);
+  return {
+    async GET(request) {
+      const url = new URL(request.url);
+      const params = chunkRTSFO7BW_cjs.listNodesParamsSchema.parse(Object.fromEntries(url.searchParams));
+      const nodes = await repo.findAll({
+        where: {},
+        limit: params.limit,
+        offset: params.page ? (params.page - 1) * (params.limit ?? 50) : void 0
+      });
+      return Response.json({
+        nodes,
+        pagination: {
+          page: params.page ?? 1,
+          limit: params.limit ?? nodes.length,
+          total: nodes.length,
+          totalPages: 1,
+          hasNext: false,
+          hasPrev: false
+        },
+        meta: {
+          queryTime: 0,
+          filters: params
+        }
+      });
+    },
+    async POST(request) {
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.nodeBatchCreateSchema.parse(body);
+      const created = await repo.batchCreate(input.nodes);
+      return Response.json({ created, skipped: [], analysisJobId: null }, { status: 201 });
+    },
+    async PATCH(request) {
+      const url = new URL(request.url);
+      const id = url.pathname.split("/").pop();
+      if (!id) return new Response("Missing id", { status: 400 });
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.nodeUpdateSchema.parse(body);
+      const updated = await repo.update(id, input);
+      return Response.json(updated);
+    },
+    async DELETE(request) {
+      const url = new URL(request.url);
+      const id = url.pathname.split("/").pop();
+      if (!id) return new Response("Missing id", { status: 400 });
+      const deleted = await repo.delete(id);
+      return Response.json({ deleted, edgesRemoved: 0 });
+    }
+  };
+};
+
+// src/api/repositories/edge-repository.ts
+var mapEdgeRow = (row) => ({
+  id: row.id,
+  fromNodeId: row.from_node_id,
+  toNodeId: row.to_node_id,
+  relationshipType: row.relationship_type,
+  strength: Number(row.strength ?? 0.5),
+  confidence: Number(row.confidence ?? 1),
+  evidence: row.evidence ?? [],
+  label: row.label ?? null,
+  description: row.description ?? null,
+  metadata: row.metadata ?? {},
+  source: row.source,
+  sourceModel: row.source_model ?? null,
+  createdAt: row.created_at,
+  updatedAt: row.updated_at,
+  bidirectional: Boolean(row.bidirectional ?? false)
+});
+var EdgeRepository = class extends BaseRepository {
+  constructor(db) {
+    super(db, "edges");
+  }
+  async findById(id) {
+    const row = await this.db.queryOne("SELECT * FROM edges WHERE id = $1", [id]);
+    return row ? mapEdgeRow(row) : null;
+  }
+  async findAll() {
+    const rows = await this.db.query("SELECT * FROM edges");
+    return rows.map(mapEdgeRow);
+  }
+  async findByNodeId(nodeId, direction = "both") {
+    let sql = "SELECT * FROM edges WHERE from_node_id = $1 OR to_node_id = $1";
+    if (direction === "inbound") {
+      sql = "SELECT * FROM edges WHERE to_node_id = $1";
+    }
+    if (direction === "outbound") {
+      sql = "SELECT * FROM edges WHERE from_node_id = $1";
+    }
+    const rows = await this.db.query(sql, [nodeId]);
+    return rows.map(mapEdgeRow);
+  }
+  async findBetweenNodes(fromId, toId) {
+    const rows = await this.db.query(
+      "SELECT * FROM edges WHERE from_node_id = $1 AND to_node_id = $2",
+      [fromId, toId]
+    );
+    return rows.map(mapEdgeRow);
+  }
+  async deleteByNodeId(nodeId) {
+    return this.db.execute("DELETE FROM edges WHERE from_node_id = $1 OR to_node_id = $1", [nodeId]);
+  }
+  async batchCreate(edges) {
+    const created = [];
+    for (const edge of edges) {
+      const row = await this.db.queryOne(
+        `INSERT INTO edges (from_node_id, to_node_id, relationship_type, strength, confidence, evidence, label, description, metadata, source, bidirectional)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, 'manual', $10)
+         RETURNING *`,
+        [
+          edge.fromNodeId,
+          edge.toNodeId,
+          edge.relationshipType ?? "related_to",
+          edge.strength ?? 0.5,
+          edge.confidence ?? 1,
+          edge.evidence ?? [],
+          edge.label ?? null,
+          edge.description ?? null,
+          edge.metadata ?? {},
+          edge.bidirectional ?? false
+        ]
+      );
+      if (row) created.push(mapEdgeRow(row));
+    }
+    return created;
+  }
+};
+
+// src/api/routes/edges.ts
+var createEdgesRoutes = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  const repo = new EdgeRepository(db);
+  return {
+    async GET(request) {
+      const url = new URL(request.url);
+      const params = chunkRTSFO7BW_cjs.listEdgesParamsSchema.parse(Object.fromEntries(url.searchParams));
+      const edges = await repo.findAll();
+      return Response.json({
+        edges,
+        pagination: {
+          page: params.page ?? 1,
+          limit: params.limit ?? edges.length,
+          total: edges.length,
+          totalPages: 1,
+          hasNext: false,
+          hasPrev: false
+        }
+      });
+    },
+    async POST(request) {
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.edgeCreateSchema.array().safeParse(body.edges ?? body);
+      if (!input.success) {
+        return Response.json({ error: input.error.message }, { status: 400 });
+      }
+      const created = await repo.batchCreate(input.data);
+      return Response.json({ created, errors: [] }, { status: 201 });
+    },
+    async PATCH(request) {
+      const url = new URL(request.url);
+      const id = url.pathname.split("/").pop();
+      if (!id) return new Response("Missing id", { status: 400 });
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.edgeUpdateSchema.parse(body);
+      const updated = await repo.update(id, input);
+      return Response.json(updated);
+    },
+    async DELETE(request) {
+      const url = new URL(request.url);
+      const id = url.pathname.split("/").pop();
+      if (!id) return new Response("Missing id", { status: 400 });
+      const deleted = await repo.delete(id);
+      return Response.json({ deleted });
+    }
+  };
+};
+
+// src/api/query-builder.ts
+var mapVisualNode = (row) => ({
+  id: row.id,
+  slug: row.slug,
+  label: row.label,
+  domain: row.domain,
+  tier: row.tier ?? void 0,
+  metadata: row.metadata ?? {},
+  ref: row.ref ?? null,
+  connectionCount: Number(row.connection_count ?? 0),
+  position: row.position_override ?? void 0
+});
+var mapVisualEdge = (row) => ({
+  id: row.id,
+  from: row.from_slug,
+  to: row.to_slug,
+  relationshipType: row.relationship_type,
+  strength: Number(row.strength ?? 0.5),
+  label: row.label ?? null
+});
+var GraphQueryBuilder = class {
+  constructor(db) {
+    this.db = db;
+  }
+  buildGraphQuery(params) {
+    const values = [];
+    const filters = [];
+    if (params.domains?.length) {
+      values.push(params.domains);
+      filters.push(`domain = ANY($${values.length})`);
+    }
+    if (params.nodeTypes?.length) {
+      values.push(params.nodeTypes);
+      filters.push(`node_type = ANY($${values.length})`);
+    }
+    if (params.clusterIds?.length) {
+      values.push(params.clusterIds);
+      filters.push(`cluster_id = ANY($${values.length})`);
+    }
+    if (params.nodeIds?.length) {
+      values.push(params.nodeIds);
+      filters.push(`id = ANY($${values.length})`);
+    }
+    const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+    const limit = params.maxNodes ? `LIMIT ${params.maxNodes}` : "";
+    const sql = `
+      WITH filtered_nodes AS (
+        SELECT * FROM nodes
+        ${where}
+        ${limit}
+      )
+      SELECT * FROM filtered_nodes;
+    `;
+    return { sql, values };
+  }
+  buildExpansionQuery(params) {
+    const values = [params.fromNodeIds, params.depth ?? 1];
+    const sql = `
+      WITH RECURSIVE expanded AS (
+        SELECT id, slug, label, domain, tier, metadata, position_override, connection_count, 1 as depth
+        FROM nodes
+        WHERE id = ANY($1)
+
+        UNION ALL
+
+        SELECT n.id, n.slug, n.label, n.domain, n.tier, n.metadata, n.position_override, n.connection_count, e.depth + 1
+        FROM expanded e
+        JOIN edges ed ON ed.from_node_id = e.id OR ed.to_node_id = e.id
+        JOIN nodes n ON (n.id = ed.from_node_id OR n.id = ed.to_node_id)
+        WHERE e.depth < $2
+      )
+      SELECT DISTINCT * FROM expanded;
+    `;
+    return { sql, values };
+  }
+  buildPathQuery(params) {
+    const values = [params.fromNodeId, params.toNodeId, params.maxDepth ?? 5];
+    const sql = `
+      WITH RECURSIVE paths AS (
+        SELECT ARRAY[from_node_id, to_node_id] as path,
+               ARRAY[id] as edge_ids,
+               strength as total_strength,
+               1 as depth
+        FROM edges
+        WHERE from_node_id = $1
+
+        UNION ALL
+
+        SELECT p.path || e.to_node_id,
+               p.edge_ids || e.id,
+               p.total_strength + e.strength,
+               p.depth + 1
+        FROM paths p
+        JOIN edges e ON e.from_node_id = p.path[array_upper(p.path, 1)]
+        WHERE NOT e.to_node_id = ANY(p.path)
+          AND p.depth < $3
+      )
+      SELECT * FROM paths
+      WHERE path[array_upper(path, 1)] = $2
+      ORDER BY array_length(path, 1), total_strength DESC;
+    `;
+    return { sql, values };
+  }
+  async getGraph(params) {
+    const { sql, values } = this.buildGraphQuery(params);
+    const nodes = await this.db.query(sql, values);
+    const nodeIds = nodes.map((node) => node.id);
+    const edges = await this.db.query(
+      `SELECT e.*, n1.slug as from_slug, n2.slug as to_slug
+       FROM edges e
+       JOIN nodes n1 ON e.from_node_id = n1.id
+       JOIN nodes n2 ON e.to_node_id = n2.id
+       WHERE e.from_node_id = ANY($1) AND e.to_node_id = ANY($1)`,
+      [nodeIds]
+    );
+    return {
+      nodes: nodes.map(mapVisualNode),
+      edges: edges.map(mapVisualEdge),
+      clusters: [],
+      meta: {
+        totalNodes: nodes.length,
+        totalEdges: edges.length,
+        truncated: Boolean(params.maxNodes && nodes.length >= params.maxNodes),
+        queryTime: 0
+      }
+    };
+  }
+  async expandGraph(params) {
+    const { sql, values } = this.buildExpansionQuery(params);
+    const nodes = await this.db.query(sql, values);
+    const nodeIds = nodes.map((node) => node.id);
+    const edges = await this.db.query(
+      `SELECT e.*, n1.slug as from_slug, n2.slug as to_slug
+       FROM edges e
+       JOIN nodes n1 ON e.from_node_id = n1.id
+       JOIN nodes n2 ON e.to_node_id = n2.id
+       WHERE e.from_node_id = ANY($1) AND e.to_node_id = ANY($1)`,
+      [nodeIds]
+    );
+    return {
+      nodes: nodes.map(mapVisualNode),
+      edges: edges.map(mapVisualEdge)
+    };
+  }
+  async findPaths(params) {
+    const { sql, values } = this.buildPathQuery(params);
+    const rows = await this.db.query(
+      sql,
+      values
+    );
+    return {
+      paths: rows.map((row) => ({
+        nodes: row.path,
+        edges: row.edge_ids,
+        length: row.path.length,
+        totalStrength: row.total_strength
+      }))
+    };
+  }
+};
+
+// src/api/routes/graph.ts
+var createGraphRoutes = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  const builder = new GraphQueryBuilder(db);
+  return {
+    async GET(request) {
+      const url = new URL(request.url);
+      const params = chunkRTSFO7BW_cjs.getGraphParamsSchema.parse(Object.fromEntries(url.searchParams));
+      const result = await builder.getGraph({
+        ...params,
+        nodeTypes: params.nodeTypes ? Array.isArray(params.nodeTypes) ? params.nodeTypes : [params.nodeTypes] : void 0,
+        domains: params.domains ? Array.isArray(params.domains) ? params.domains : [params.domains] : void 0,
+        clusterIds: params.clusterIds ? Array.isArray(params.clusterIds) ? params.clusterIds : [params.clusterIds] : void 0,
+        nodeIds: params.nodeIds ? Array.isArray(params.nodeIds) ? params.nodeIds : [params.nodeIds] : void 0,
+        relationshipTypes: params.relationshipTypes ? Array.isArray(params.relationshipTypes) ? params.relationshipTypes : [params.relationshipTypes] : void 0
+      });
+      return Response.json(result);
+    },
+    async POST(request) {
+      const url = new URL(request.url);
+      if (url.pathname.endsWith("/expand")) {
+        const body = await request.json();
+        const input = chunkRTSFO7BW_cjs.expandGraphRequestSchema.parse(body);
+        const result = await builder.expandGraph(input);
+        return Response.json(result);
+      }
+      if (url.pathname.endsWith("/path")) {
+        const body = await request.json();
+        const input = chunkRTSFO7BW_cjs.findPathRequestSchema.parse(body);
+        const result = await builder.findPaths(input);
+        return Response.json(result);
+      }
+      return new Response("Unsupported", { status: 404 });
+    }
+  };
+};
+
+// src/api/routes/analyze.ts
+var buildPipeline = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  const events = new chunkCOO66N7H_cjs.EventBus();
+  const embeddings = new chunkCOO66N7H_cjs.EmbeddingsService(
+    {
+      openaiApiKey: config.openai.apiKey,
+      model: config.analysis.embeddingModel,
+      batchSize: config.analysis.embeddingBatchSize,
+      rateLimit: config.analysis.openaiRateLimit,
+      cacheTTL: config.analysis.embeddingCacheTTL,
+      maxRetries: config.openai.maxRetries ?? 3
+    },
+    db
+  );
+  const clustering = new chunkCOO66N7H_cjs.ClusteringEngine(db, embeddings);
+  const relationships = new chunkCOO66N7H_cjs.RelationshipEngine(db, {
+    model: config.analysis.relationshipInferenceModel,
+    minConfidence: config.analysis.relationshipMinConfidence,
+    maxPerNode: config.analysis.relationshipMaxPerNode,
+    similarityThreshold: config.analysis.clusterSimilarityThreshold,
+    includeExisting: true,
+    batchSize: 10,
+    rateLimit: config.analysis.openaiRateLimit
+  });
+  return new chunkCOO66N7H_cjs.AnalysisPipeline(db, embeddings, clustering, relationships, events);
+};
+var createAnalyzeRoutes = (config) => {
+  return {
+    async POST(request) {
+      const url = new URL(request.url);
+      if (url.pathname.endsWith("/cancel")) {
+        const jobId = url.pathname.split("/").slice(-2)[0];
+        const pipeline2 = buildPipeline(config);
+        const cancelled = await pipeline2.cancelJob(jobId);
+        return Response.json({ cancelled });
+      }
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.analysisRequestSchema.parse(body);
+      const pipeline = buildPipeline(config);
+      let job;
+      if (input.action === "embeddings") {
+        job = await pipeline.runEmbeddings(input.options ?? {});
+      } else if (input.action === "cluster") {
+        job = await pipeline.runClustering(input.options ?? {});
+      } else if (input.action === "infer_relationships") {
+        job = await pipeline.runRelationships(input.options ?? {});
+      } else {
+        job = await pipeline.runFull(input.options ?? {});
+      }
+      return Response.json({ jobId: job.id, status: job.status });
+    },
+    async GET(request) {
+      const url = new URL(request.url);
+      if (url.pathname.endsWith("/history")) {
+        const pipeline2 = buildPipeline(config);
+        const jobs = await pipeline2.listJobs({ limit: 50 });
+        return Response.json({ jobs });
+      }
+      const jobId = url.pathname.split("/").pop();
+      if (!jobId) return new Response("Missing job id", { status: 400 });
+      const pipeline = buildPipeline(config);
+      const job = await pipeline.getJob(jobId);
+      return Response.json({ job });
+    }
+  };
+};
+
+// src/api/repositories/settings-repository.ts
+var deepMerge = (target, source) => {
+  const output = { ...target };
+  Object.entries(source).forEach(([key, value]) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      output[key] = deepMerge(output[key] ?? {}, value);
+    } else if (value !== void 0) {
+      output[key] = value;
+    }
+  });
+  return output;
+};
+var defaultSettings = () => ({
+  instance: {
+    name: "default",
+    version: "0.1.0",
+    repoName: "omi-neuron-web"
+  },
+  visualization: chunkRTSFO7BW_cjs.DEFAULT_VISUALIZATION_SETTINGS,
+  analysis: chunkRTSFO7BW_cjs.DEFAULT_ANALYSIS_SETTINGS,
+  nodeTypes: [],
+  domains: [],
+  relationshipTypes: []
+});
+var SettingsRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async get() {
+    const row = await this.db.queryOne("SELECT visualization, analysis, node_types, domains, relationship_types FROM settings WHERE id = $1", [
+      "default"
+    ]);
+    if (!row) {
+      return defaultSettings();
+    }
+    return {
+      ...defaultSettings(),
+      visualization: { ...chunkRTSFO7BW_cjs.DEFAULT_VISUALIZATION_SETTINGS, ...row.visualization ?? {} },
+      analysis: { ...chunkRTSFO7BW_cjs.DEFAULT_ANALYSIS_SETTINGS, ...row.analysis ?? {} },
+      nodeTypes: row.node_types ?? [],
+      domains: row.domains ?? [],
+      relationshipTypes: row.relationship_types ?? []
+    };
+  }
+  async update(settings) {
+    const current = await this.get();
+    const merged = deepMerge(current, settings);
+    await this.db.execute(
+      `INSERT INTO settings (id, visualization, analysis, node_types, domains, relationship_types)
+       VALUES ('default', $1, $2, $3, $4, $5)
+       ON CONFLICT (id) DO UPDATE SET visualization = $1, analysis = $2, node_types = $3, domains = $4, relationship_types = $5, updated_at = NOW()`,
+      [
+        merged.visualization,
+        merged.analysis,
+        merged.nodeTypes,
+        merged.domains,
+        merged.relationshipTypes
+      ]
+    );
+    return merged;
+  }
+  async reset(sections) {
+    const defaults = defaultSettings();
+    if (sections?.length) {
+      const current = await this.get();
+      const updated = { ...current };
+      sections.forEach((section) => {
+        updated[section] = defaults[section];
+      });
+      return this.update(updated);
+    }
+    await this.db.execute(
+      `INSERT INTO settings (id, visualization, analysis, node_types, domains, relationship_types)
+       VALUES ('default', $1, $2, $3, $4, $5)
+       ON CONFLICT (id) DO UPDATE SET visualization = $1, analysis = $2, node_types = $3, domains = $4, relationship_types = $5, updated_at = NOW()`,
+      [
+        defaults.visualization,
+        defaults.analysis,
+        defaults.nodeTypes,
+        defaults.domains,
+        defaults.relationshipTypes
+      ]
+    );
+    return defaults;
+  }
+};
+
+// src/api/routes/settings.ts
+var createSettingsRoutes = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  const repo = new SettingsRepository(db);
+  return {
+    async GET() {
+      const settings = await repo.get();
+      return Response.json({ settings });
+    },
+    async PATCH(request) {
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.neuronSettingsUpdateSchema.parse(body);
+      const settings = await repo.update(input);
+      return Response.json({ settings });
+    },
+    async POST(request) {
+      const url = new URL(request.url);
+      if (!url.pathname.endsWith("/reset")) {
+        return new Response("Not found", { status: 404 });
+      }
+      const body = await request.json().catch(() => ({}));
+      const settings = await repo.reset(body?.sections);
+      return Response.json({ settings });
+    }
+  };
+};
+
+// src/api/routes/search.ts
+var createSearchRoutes = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  const embeddings = new chunkCOO66N7H_cjs.EmbeddingsService(
+    {
+      openaiApiKey: config.openai.apiKey,
+      model: config.analysis.embeddingModel,
+      batchSize: config.analysis.embeddingBatchSize,
+      rateLimit: config.analysis.openaiRateLimit,
+      cacheTTL: config.analysis.embeddingCacheTTL,
+      maxRetries: config.openai.maxRetries ?? 3
+    },
+    db
+  );
+  const scoring = new chunkRTSFO7BW_cjs.ScoringEngine(db);
+  return {
+    async POST(request) {
+      const url = new URL(request.url);
+      if (url.pathname.endsWith("/similar")) {
+        const body2 = await request.json();
+        const input2 = chunkRTSFO7BW_cjs.findSimilarRequestSchema.parse(body2);
+        const results2 = await scoring.findSimilar(input2.nodeId, input2.limit ?? 10, input2.excludeConnected ?? false);
+        return Response.json({ results: results2 });
+      }
+      const body = await request.json();
+      const input = chunkRTSFO7BW_cjs.semanticSearchRequestSchema.parse(body);
+      const embedding = await embeddings.generateEmbedding(input.query);
+      const results = await scoring.scoreForQuery(embedding);
+      return Response.json({ results: results.slice(0, input.limit ?? 10) });
+    }
+  };
+};
+
+// src/api/routes/health.ts
+var createHealthRoutes = (config) => {
+  const db = chunkRTSFO7BW_cjs.createDatabase(config);
+  return {
+    async GET() {
+      const ok = await db.isConnected();
+      return Response.json({ status: ok ? "ok" : "degraded", time: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  };
+};
+
+// src/api/routes/factory.ts
+function createNeuronRoutes(config) {
+  return {
+    nodes: createNodesRoutes(config),
+    edges: createEdgesRoutes(config),
+    graph: createGraphRoutes(config),
+    analyze: createAnalyzeRoutes(config),
+    settings: createSettingsRoutes(config),
+    search: createSearchRoutes(config),
+    health: createHealthRoutes(config)
+  };
+}
+
+// src/api/repositories/cluster-repository.ts
+var mapClusterRow = (row) => ({
+  id: row.id,
+  label: row.label,
+  clusterType: row.cluster_type ?? "topic",
+  centroid: row.centroid ?? [],
+  memberCount: Number(row.member_count ?? 0),
+  avgSimilarity: row.avg_similarity ?? 0,
+  cohesion: row.cohesion ?? 0,
+  description: row.description ?? null,
+  keywords: row.keywords ?? [],
+  metadata: row.metadata ?? {},
+  createdAt: row.created_at,
+  updatedAt: row.updated_at,
+  lastRecomputedAt: row.last_recomputed_at ?? null
+});
+var ClusterRepository = class extends BaseRepository {
+  constructor(db) {
+    super(db, "clusters");
+  }
+  async findById(id) {
+    const row = await this.db.queryOne("SELECT * FROM clusters WHERE id = $1", [id]);
+    return row ? mapClusterRow(row) : null;
+  }
+  async findWithMembers(clusterId) {
+    const cluster = await this.findById(clusterId);
+    const memberships = await this.db.query(
+      "SELECT node_id, similarity_score FROM cluster_memberships WHERE cluster_id = $1",
+      [clusterId]
+    );
+    return {
+      cluster,
+      members: memberships.map((row) => ({ nodeId: row.node_id, similarityScore: row.similarity_score }))
+    };
+  }
+  async updateCentroid(clusterId, centroid) {
+    await this.db.execute("UPDATE clusters SET centroid = $1 WHERE id = $2", [centroid, clusterId]);
+  }
+  async addMember(clusterId, nodeId, similarity) {
+    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",
+      [nodeId, clusterId, similarity]
+    );
+  }
+  async removeMember(clusterId, nodeId) {
+    await this.db.execute("DELETE FROM cluster_memberships WHERE cluster_id = $1 AND node_id = $2", [
+      clusterId,
+      nodeId
+    ]);
+  }
+};
+
+// src/api/repositories/analysis-run-repository.ts
+var AnalysisRunRepository = class extends BaseRepository {
+  constructor(db) {
+    super(db, "analysis_runs");
+  }
+  async findActive() {
+    return this.db.query("SELECT * FROM analysis_runs WHERE status = $1", ["running"]);
+  }
+  async updateProgress(id, progress) {
+    await this.db.execute("UPDATE analysis_runs SET progress = $1 WHERE id = $2", [progress, id]);
+  }
+  async markCompleted(id, results) {
+    await this.db.execute(
+      "UPDATE analysis_runs SET status = $1, results = $2, completed_at = NOW() WHERE id = $3",
+      ["completed", results, id]
+    );
+  }
+  async markFailed(id, error) {
+    await this.db.execute(
+      "UPDATE analysis_runs SET status = $1, error_message = $2, completed_at = NOW() WHERE id = $3",
+      ["failed", error, id]
+    );
+  }
+};
+
+// src/api/middleware/cors.ts
+var withCors = (options) => (handler) => async (request) => {
+  if (request.method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: buildCorsHeaders(options)
+    });
+  }
+  const response = await handler(request);
+  const headers = new Headers(response.headers);
+  const corsHeaders = buildCorsHeaders(options);
+  corsHeaders.forEach((value, key) => headers.set(key, value));
+  return new Response(response.body, { status: response.status, headers });
+};
+var buildCorsHeaders = (options) => {
+  const headers = new Headers();
+  headers.set("Access-Control-Allow-Origin", options?.origins?.join(",") ?? "*");
+  headers.set("Access-Control-Allow-Methods", "GET,POST,PATCH,DELETE,OPTIONS");
+  headers.set("Access-Control-Allow-Headers", "Content-Type,Authorization");
+  return headers;
+};
+
+// src/api/middleware/error-handler.ts
+var ApiError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var handleError = (error) => {
+  if (error instanceof ApiError) {
+    return Response.json(
+      {
+        error: error.message,
+        code: error.code,
+        statusCode: error.statusCode,
+        details: error.details
+      },
+      { status: error.statusCode }
+    );
+  }
+  const message = error instanceof Error ? error.message : "Internal error";
+  return Response.json(
+    {
+      error: message,
+      code: "INTERNAL_ERROR",
+      statusCode: 500
+    },
+    { status: 500 }
+  );
+};
+var withErrorHandler = (handler) => async (request) => {
+  try {
+    return await handler(request);
+  } catch (error) {
+    return handleError(error);
+  }
+};
+
+// src/api/middleware/logging.ts
+var withLogging = (handler) => async (request) => {
+  const start = Date.now();
+  const response = await handler(request);
+  const duration = Date.now() - start;
+  console.log(`[omi-neuron] ${request.method} ${request.url} -> ${response.status} (${duration}ms)`);
+  return response;
+};
+
+// src/api/middleware/timing.ts
+var withTiming = (handler) => async (request) => {
+  const start = Date.now();
+  const response = await handler(request);
+  const duration = Date.now() - start;
+  const headers = new Headers(response.headers);
+  headers.set("X-Response-Time", `${duration}ms`);
+  return new Response(response.body, { status: response.status, headers });
+};
+
+// src/api/middleware/index.ts
+var compose = (...handlers) => {
+  return (handler) => handlers.reduceRight((acc, fn) => fn(acc), handler);
+};
+var withNeuronMiddleware = (handler, options) => {
+  const chain = [withErrorHandler, withLogging, withTiming];
+  if (options?.cors) {
+    chain.push(withCors(options.cors));
+  }
+  return compose(...chain)(handler);
+};
+
+exports.AnalysisRunRepository = AnalysisRunRepository;
+exports.ClusterRepository = ClusterRepository;
+exports.EdgeRepository = EdgeRepository;
+exports.GraphQueryBuilder = GraphQueryBuilder;
+exports.NodeRepository = NodeRepository;
+exports.SettingsRepository = SettingsRepository;
+exports.createNeuronRoutes = createNeuronRoutes;
+exports.withNeuronMiddleware = withNeuronMiddleware;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map