@omiron33/omi-neuron-web 0.1.0

package/dist/index.js

@@ -0,0 +1,654 @@
+import { nodeCreateSchema, DEFAULT_ANALYSIS_SETTINGS, DEFAULT_VISUALIZATION_SETTINGS } from './chunk-XNR42GCJ.js';
+export { DEFAULT_ANALYSIS_SETTINGS, DEFAULT_VISUALIZATION_SETTINGS, ScoringEngine, analysisOptionsSchema, analysisRequestSchema, analysisSettingsSchema, buildDelete, buildInsert, buildSelect, buildUpdate, buildWhereClause, createDatabase, createDatabaseFromEnv, databaseSettingsSchema, domainConfigSchema, edgeCreateSchema, edgeEvidenceSchema, edgeFilterSchema, edgeUpdateSchema, expandGraphRequestSchema, findPathRequestSchema, findSimilarRequestSchema, getDatabase, getGraphParamsSchema, listEdgesParamsSchema, listNodesParamsSchema, neuronConfigSchema, neuronSettingsSchema, neuronSettingsUpdateSchema, nodeBatchCreateSchema, nodeCreateSchema, nodeFilterSchema, nodeTierSchema, nodeTypeConfigSchema, nodeUpdateSchema, paginationSchema, relationshipTypeConfigSchema, resetDatabaseSingleton, semanticSearchRequestSchema, visualizationSettingsSchema } from './chunk-XNR42GCJ.js';
+export { DockerManager } from './chunk-TFLMPBX7.js';
+import { createEvent, EventBus } from './chunk-RQCGONPN.js';
+export { AnalysisPipeline, ClusteringEngine, Database, EmbeddingsService, EventBus, RelationshipEngine, createEvent } from './chunk-RQCGONPN.js';
+export { MigrationRunner, migration001, migration002, migration003, migration004, migrations } from './chunk-PSDVPB7Y.js';
+import { z } from 'zod';
+import slugify from 'slugify';
+import { createContext, useContext, useState, useCallback, useEffect, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var clusteringConfigSchema = z.object({
+  algorithm: z.enum(["kmeans", "dbscan", "hierarchical"]),
+  clusterCount: z.coerce.number().int().min(1).optional(),
+  minClusterSize: z.coerce.number().int().min(1).optional(),
+  similarityThreshold: z.coerce.number().min(0).max(1).optional(),
+  epsilon: z.coerce.number().min(0).optional(),
+  minSamples: z.coerce.number().int().min(1).optional()
+});
+var clusterCreateSchema = z.object({
+  label: z.string().min(1).max(255),
+  clusterType: z.string().max(100).optional(),
+  centroid: z.array(z.number()).optional(),
+  memberCount: z.number().int().min(0).optional(),
+  avgSimilarity: z.number().min(0).max(1).optional(),
+  cohesion: z.number().min(0).max(1).optional(),
+  description: z.string().optional(),
+  keywords: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var clusterUpdateSchema = clusterCreateSchema.partial();
+
+// src/core/events/helpers.ts
+var createNodeEvent = (type, payload, source = "system") => createEvent(type, payload, source);
+var createEdgeEvent = (type, payload, source = "system") => createEvent(type, payload, source);
+var createAnalysisEvent = (type, payload, source = "analysis") => createEvent(type, payload, source);
+var createGenericEvent = (type, payload, source = "system") => createEvent(type, payload, source);
+
+// src/core/events/middleware/logging.ts
+var loggingMiddleware = (event, next) => {
+  console.debug(`[omi-neuron:event] ${event.type}`, event);
+  void next();
+};
+
+// src/core/events/middleware/validation.ts
+var validationMiddleware = (event, next) => {
+  if (!event.type) {
+    throw new Error("Event missing type");
+  }
+  if (!event.timestamp) {
+    throw new Error("Event missing timestamp");
+  }
+  return next();
+};
+var stripHtml = (value) => value.replace(/<[^>]+>/g, " ");
+var normalizeValue = (value) => {
+  if (value === null || value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map((item) => normalizeValue(item)).filter(Boolean).join(" ");
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+};
+var flattenObject = (obj, prefix = "") => {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const nextKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+      Object.assign(result, flattenObject(value, nextKey));
+    } else {
+      result[nextKey] = value;
+    }
+  }
+  return result;
+};
+var DataProcessor = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  processItem(item) {
+    const flattened = flattenObject(item);
+    const labelField = this.options.labelField ?? "label";
+    const label = normalizeValue(flattened[labelField]) ?? "Untitled";
+    const slugField = this.options.slugField;
+    const slug = slugField ? normalizeValue(flattened[slugField]) : void 0;
+    const content = this.extractContent(flattened);
+    const metadata = this.extractMetadata(flattened);
+    const node = {
+      slug,
+      label,
+      nodeType: this.options.defaultNodeType,
+      domain: this.options.defaultDomain,
+      content,
+      metadata
+    };
+    return nodeCreateSchema.parse(node);
+  }
+  processBatch(items) {
+    const nodes = [];
+    const errors = [];
+    items.forEach((item, index) => {
+      try {
+        nodes.push(this.processItem(item));
+      } catch (error) {
+        errors.push({
+          index,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    return { nodes, errors };
+  }
+  processJSON(json) {
+    const parsed = JSON.parse(json);
+    if (Array.isArray(parsed)) {
+      return this.processBatch(parsed).nodes;
+    }
+    return [this.processItem(parsed)];
+  }
+  processCSV(csv) {
+    const lines = csv.trim().split(/\r?\n/);
+    if (lines.length === 0) return [];
+    const headers = lines[0].split(",").map((h) => h.trim());
+    const items = lines.slice(1).map((line) => {
+      const values = line.split(",");
+      const item = {};
+      headers.forEach((header, idx) => {
+        item[header] = values[idx]?.trim();
+      });
+      return item;
+    });
+    return this.processBatch(items).nodes;
+  }
+  generateSlug(label, existingSlugs = /* @__PURE__ */ new Set()) {
+    const base = slugify(label, { lower: true, strict: true, trim: true }).slice(0, 255);
+    if (!existingSlugs.has(base)) return base;
+    let suffix = 1;
+    let slug = `${base}-${suffix}`;
+    while (existingSlugs.has(slug)) {
+      suffix += 1;
+      slug = `${base}-${suffix}`;
+    }
+    return slug;
+  }
+  extractContent(item) {
+    const fields = this.options.contentFields ?? ["label", "summary", "description", "content"];
+    const parts = fields.map((field) => normalizeValue(item[field])).filter((value) => Boolean(value));
+    const joined = parts.join(" ");
+    return stripHtml(joined).replace(/\s+/g, " ").trim();
+  }
+  detectDuplicates(nodes) {
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    const duplicates = [];
+    nodes.forEach((node) => {
+      const slug = node.slug ?? this.generateSlug(node.label, seen);
+      if (seen.has(slug)) {
+        duplicates.push({ node, reason: `Duplicate slug: ${slug}` });
+        return;
+      }
+      seen.add(slug);
+      unique.push({ ...node, slug });
+    });
+    return { unique, duplicates };
+  }
+  extractMetadata(item) {
+    if (!this.options.metadataFields?.length) return void 0;
+    const metadata = {};
+    this.options.metadataFields.forEach((field) => {
+      if (field in item) {
+        metadata[field] = item[field];
+      }
+    });
+    return Object.keys(metadata).length > 0 ? metadata : void 0;
+  }
+};
+
+// src/config/index.ts
+var defineNeuronConfig = (config) => config;
+var NeuronContext = createContext(null);
+
+// src/react/hooks/useNeuronContext.ts
+function useNeuronContext() {
+  const context = useContext(NeuronContext);
+  if (!context) {
+    throw new Error("useNeuronContext must be used within NeuronWebProvider");
+  }
+  return context;
+}
+function useNeuronGraph(options) {
+  const { api } = useNeuronContext();
+  const [nodes, setNodes] = useState([]);
+  const [edges, setEdges] = useState([]);
+  const [clusters, setClusters] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [filters, setFilters] = useState({});
+  const [selectedNode, setSelectedNode] = useState(null);
+  const fetchGraph = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const params = {
+        domains: options?.domains,
+        nodeTypes: options?.nodeTypes,
+        minEdgeStrength: options?.minEdgeStrength
+      };
+      const response = await api.graph.get(params);
+      setNodes(response.nodes);
+      setEdges(response.edges);
+      setClusters(response.clusters ?? []);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [api, options]);
+  useEffect(() => {
+    void fetchGraph();
+  }, [fetchGraph]);
+  const expandFromNode = async (nodeId, depth = 1) => {
+    const response = await api.graph.expand({ fromNodeIds: [nodeId], depth, direction: "both" });
+    setNodes(response.nodes);
+    setEdges(response.edges);
+  };
+  const findPath = async (fromId, toId) => {
+    const response = await api.graph.findPath({ fromNodeId: fromId, toNodeId: toId });
+    return response.paths[0];
+  };
+  return {
+    nodes,
+    edges,
+    clusters,
+    isLoading,
+    error,
+    filters,
+    setFilters: (next) => setFilters((prev) => ({ ...prev, ...next })),
+    clearFilters: () => setFilters({}),
+    selectedNode: selectedNode ? nodes.find((node) => node.id === selectedNode) ?? null : null,
+    selectNode: (nodeId) => setSelectedNode(nodeId),
+    clearSelection: () => setSelectedNode(null),
+    refetch: fetchGraph,
+    expandFromNode,
+    findPath
+  };
+}
+function useNeuronNodes(options) {
+  const { api } = useNeuronContext();
+  const [nodes, setNodes] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [page, setPage] = useState(1);
+  const [totalPages, setTotalPages] = useState(1);
+  const fetchNodes = useCallback(async () => {
+    setIsLoading(true);
+    try {
+      const response = await api.nodes.list({
+        ...options?.initialFilters,
+        page,
+        limit: options?.pageSize ?? 50
+      });
+      setNodes(response.nodes);
+      setTotalPages(response.pagination.totalPages ?? 1);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [api, options, page]);
+  useEffect(() => {
+    void fetchNodes();
+  }, [fetchNodes]);
+  return {
+    nodes,
+    isLoading,
+    error,
+    createNode: async (data) => {
+      const response = await api.nodes.create({ nodes: [data] });
+      await fetchNodes();
+      return response.created[0];
+    },
+    updateNode: async (id, data) => {
+      const updated = await api.nodes.update(id, data);
+      await fetchNodes();
+      return updated;
+    },
+    deleteNode: async (id) => {
+      await api.nodes.delete(id);
+      await fetchNodes();
+    },
+    batchCreate: async (nodesInput) => {
+      const response = await api.nodes.create({ nodes: nodesInput });
+      await fetchNodes();
+      return response.created;
+    },
+    search: async (query) => {
+      const response = await api.nodes.list({ search: query });
+      setNodes(response.nodes);
+    },
+    pagination: {
+      page,
+      totalPages,
+      hasNext: page < totalPages,
+      hasPrev: page > 1
+    },
+    setPage,
+    nextPage: () => setPage((prev) => Math.min(prev + 1, totalPages)),
+    prevPage: () => setPage((prev) => Math.max(prev - 1, 1))
+  };
+}
+function useNeuronAnalysis() {
+  const { api } = useNeuronContext();
+  const [activeJobs, setActiveJobs] = useState([]);
+  const [jobHistory, setJobHistory] = useState([]);
+  const [isRunning, setIsRunning] = useState(false);
+  const [currentProgress, setCurrentProgress] = useState(null);
+  const startAnalysis = async (request) => {
+    setIsRunning(true);
+    const response = await api.analyze.start(request);
+    setActiveJobs((prev) => [...prev, { ...response }]);
+    return response;
+  };
+  const cancelJob = async (jobId) => {
+    await api.analyze.cancel(jobId);
+    setActiveJobs((prev) => prev.filter((job) => job.id !== jobId));
+  };
+  const getJobStatus = async (jobId) => {
+    const response = await api.analyze.getStatus(jobId);
+    setJobHistory((prev) => [...prev, response.job]);
+    setIsRunning(false);
+    setCurrentProgress(response.job.progress ?? null);
+    return response.job;
+  };
+  return {
+    activeJobs,
+    jobHistory,
+    startAnalysis,
+    cancelJob,
+    getJobStatus,
+    isRunning,
+    currentProgress
+  };
+}
+function useNeuronSettings() {
+  const { settings, api, updateSettings } = useNeuronContext();
+  const [isLoading] = useState(false);
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [error, setError] = useState(null);
+  const update = async (updates) => {
+    try {
+      setIsUpdating(true);
+      await updateSettings(updates);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsUpdating(false);
+    }
+  };
+  const reset = async (sections) => {
+    await api.settings.reset();
+    if (sections?.length) {
+      await update({});
+    }
+  };
+  return {
+    settings,
+    isLoading,
+    isUpdating,
+    error,
+    updateSettings: update,
+    resetSettings: reset,
+    setDomainColor: async (domain, color) => {
+      await update({
+        visualization: {
+          ...settings.visualization,
+          domainColors: { ...settings.visualization.domainColors, [domain]: color }
+        }
+      });
+    },
+    setVisualization: async (updates) => {
+      await update({ visualization: updates });
+    }
+  };
+}
+function useNeuronSearch() {
+  const { api } = useNeuronContext();
+  const [results, setResults] = useState([]);
+  const [isSearching, setIsSearching] = useState(false);
+  const [error, setError] = useState(null);
+  const search = async (query, options) => {
+    setIsSearching(true);
+    try {
+      const response = await api.search.semantic({ query, ...options });
+      setResults(response.results);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsSearching(false);
+    }
+  };
+  const findSimilar = async (nodeId, options) => {
+    setIsSearching(true);
+    try {
+      const response = await api.search.similar({ nodeId, ...options });
+      setResults(response.results);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsSearching(false);
+    }
+  };
+  return {
+    results,
+    isSearching,
+    error,
+    search,
+    findSimilar,
+    clearResults: () => setResults([])
+  };
+}
+function useNeuronEvents() {
+  const { events } = useNeuronContext();
+  return {
+    subscribe: (type, handler) => {
+      useEffect(() => {
+        const sub = events.subscribe(type, handler);
+        return () => sub.unsubscribe();
+      }, [type, handler]);
+    },
+    emit: (type, payload) => {
+      events.emit(createEvent(type, payload, "ui"));
+    }
+  };
+}
+function useNodeEvents(handlers) {
+  const { events } = useNeuronContext();
+  useEffect(() => {
+    const subs = [];
+    if (handlers.onCreated) {
+      subs.push(
+        events.subscribe(
+          "node:created",
+          (event) => handlers.onCreated?.(event.payload.node)
+        )
+      );
+    }
+    if (handlers.onUpdated) {
+      subs.push(
+        events.subscribe(
+          "node:updated",
+          (event) => handlers.onUpdated?.(event.payload.node)
+        )
+      );
+    }
+    if (handlers.onDeleted) {
+      subs.push(
+        events.subscribe(
+          "node:deleted",
+          (event) => handlers.onDeleted?.(event.payload.nodeId)
+        )
+      );
+    }
+    return () => subs.forEach((sub) => sub.unsubscribe());
+  }, [handlers]);
+}
+function useAnalysisEvents(handlers) {
+  const { events } = useNeuronContext();
+  useEffect(() => {
+    const subs = [];
+    if (handlers.onStarted) {
+      subs.push(
+        events.subscribe(
+          "analysis:started",
+          (event) => handlers.onStarted?.(event.payload.jobId)
+        )
+      );
+    }
+    if (handlers.onProgress) {
+      subs.push(
+        events.subscribe("analysis:progress", (event) => {
+          const payload = event.payload;
+          return handlers.onProgress?.(payload.jobId, payload.progress);
+        })
+      );
+    }
+    if (handlers.onCompleted) {
+      subs.push(
+        events.subscribe(
+          "analysis:completed",
+          (event) => handlers.onCompleted?.(event.payload.job)
+        )
+      );
+    }
+    if (handlers.onFailed) {
+      subs.push(
+        events.subscribe("analysis:failed", (event) => {
+          const payload = event.payload;
+          return handlers.onFailed?.(payload.jobId, payload.error);
+        })
+      );
+    }
+    return () => subs.forEach((sub) => sub.unsubscribe());
+  }, [handlers]);
+}
+
+// src/react/api-client.ts
+var NeuronApiClient = class {
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  async request(path, options) {
+    const response = await fetch(`${this.basePath}${path}`, {
+      headers: { "Content-Type": "application/json" },
+      ...options
+    });
+    if (!response.ok) {
+      throw new Error(`Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  nodes = {
+    list: (params) => this.request(`/nodes?${new URLSearchParams(params)}`),
+    get: (id) => this.request(`/nodes/${id}`),
+    create: (data) => this.request("/nodes", { method: "POST", body: JSON.stringify(data) }),
+    update: (id, data) => this.request(`/nodes/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+    delete: (id) => this.request(`/nodes/${id}`, { method: "DELETE" })
+  };
+  edges = {
+    list: (params) => this.request(`/edges?${new URLSearchParams(params)}`),
+    create: (data) => this.request("/edges", { method: "POST", body: JSON.stringify(data) }),
+    update: (id, data) => this.request(`/edges/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+    delete: (id) => this.request(`/edges/${id}`, { method: "DELETE" })
+  };
+  graph = {
+    get: (params) => this.request(`/graph?${new URLSearchParams(params)}`),
+    expand: (data) => this.request("/graph/expand", { method: "POST", body: JSON.stringify(data) }),
+    findPath: (data) => this.request("/graph/path", { method: "POST", body: JSON.stringify(data) })
+  };
+  analyze = {
+    start: (data) => this.request("/analyze", { method: "POST", body: JSON.stringify(data) }),
+    getStatus: (jobId) => this.request(`/analyze/${jobId}`),
+    cancel: (jobId) => this.request(`/analyze/${jobId}/cancel`, { method: "POST" })
+  };
+  settings = {
+    get: () => this.request("/settings"),
+    update: (data) => this.request("/settings", { method: "PATCH", body: JSON.stringify(data) }),
+    reset: () => this.request("/settings/reset", { method: "POST" })
+  };
+  search = {
+    semantic: (data) => this.request("/search", { method: "POST", body: JSON.stringify(data) }),
+    similar: (data) => this.request("/search/similar", { method: "POST", body: JSON.stringify(data) })
+  };
+};
+var buildDefaultConfig = (overrides) => ({
+  instance: {
+    name: "default",
+    version: "0.1.0",
+    repoName: "omi-neuron-web"
+  },
+  visualization: { ...DEFAULT_VISUALIZATION_SETTINGS, ...overrides?.visualization ?? {} },
+  analysis: { ...DEFAULT_ANALYSIS_SETTINGS, ...overrides?.analysis ?? {} },
+  nodeTypes: overrides?.nodeTypes ?? [],
+  domains: overrides?.domains ?? [],
+  relationshipTypes: overrides?.relationshipTypes ?? [],
+  openai: {
+    apiKey: ""
+  },
+  database: {
+    mode: "external",
+    port: 5433,
+    url: void 0
+  },
+  api: {
+    basePath: "/api/neuron",
+    enableCors: false
+  },
+  logging: {
+    level: "info",
+    prettyPrint: true
+  }
+});
+function NeuronWebProvider({ children, config }) {
+  const [settings, setSettings] = useState(
+    () => buildDefaultConfig(config.settings)
+  );
+  const [error, setError] = useState(null);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const resolvedConfig = useMemo(() => {
+    const base = buildDefaultConfig(config.settings);
+    return {
+      ...base,
+      openai: {
+        apiKey: config.openaiApiKey ?? base.openai.apiKey
+      },
+      database: {
+        ...base.database,
+        url: config.databaseUrl ?? base.database.url
+      }
+    };
+  }, [config]);
+  const apiClient = useMemo(() => new NeuronApiClient(resolvedConfig.api.basePath), [resolvedConfig]);
+  const eventBus = useMemo(() => new EventBus(), []);
+  useEffect(() => {
+    eventBus.subscribeAll((event) => config.onEvent?.(event));
+  }, [eventBus, config]);
+  useEffect(() => {
+    let mounted = true;
+    apiClient.settings.get().then((response) => {
+      if (mounted) {
+        setSettings(response.settings);
+        setIsInitialized(true);
+      }
+    }).catch((err) => {
+      setError(err);
+      config.onError?.(err, { message: "Failed to load settings" });
+    });
+    return () => {
+      mounted = false;
+    };
+  }, [apiClient]);
+  const updateSettings = async (updates) => {
+    const response = await apiClient.settings.update(updates);
+    setSettings(response.settings);
+  };
+  const resetSettings = async () => {
+    const response = await apiClient.settings.reset();
+    setSettings(response.settings);
+  };
+  const contextValue = useMemo(
+    () => ({
+      config: resolvedConfig,
+      settings,
+      api: apiClient,
+      events: eventBus,
+      isInitialized,
+      error,
+      updateSettings,
+      resetSettings,
+      onEvent: config.onEvent,
+      onError: config.onError
+    }),
+    [resolvedConfig, settings, apiClient, eventBus, isInitialized, error, config]
+  );
+  return /* @__PURE__ */ jsx(NeuronContext.Provider, { value: contextValue, children });
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+export { DataProcessor, NeuronWebProvider, VERSION, clusterCreateSchema, clusterUpdateSchema, clusteringConfigSchema, createAnalysisEvent, createEdgeEvent, createGenericEvent, createNodeEvent, defineNeuronConfig, loggingMiddleware, useAnalysisEvents, useNeuronAnalysis, useNeuronContext, useNeuronEvents, useNeuronGraph, useNeuronNodes, useNeuronSearch, useNeuronSettings, useNodeEvents, validationMiddleware };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map