@pyxmate/memory 0.0.1-beta

package/dist/react.mjs

@@ -0,0 +1,154 @@
+import {
+  DashboardClient,
+  Poller,
+  analyzeConsolidationLog,
+  computeMetrics,
+  computeTypeDistribution,
+  enrichHealth,
+  formatBytes,
+  formatUptime,
+  toD3ForceFormat,
+  toGraphologyFormat,
+  transformGraphData,
+  unreachableHealth
+} from "./chunk-EDIYGMT2.mjs";
+import "./chunk-Q4QIILKH.mjs";
+
+// ../dashboard/src/hooks/use-consolidation-log.ts
+import { useCallback as useCallback2, useMemo } from "react";
+
+// ../dashboard/src/hooks/use-polling.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function usePolling(fetcher, options) {
+  const { intervalMs, enabled = true } = options;
+  const [data, setData] = useState(null);
+  const [error, setError] = useState(null);
+  const [isLoading, setIsLoading] = useState(enabled);
+  const [lastUpdated, setLastUpdated] = useState(null);
+  const fetchIdRef = useRef(0);
+  const poll = useCallback(async () => {
+    fetchIdRef.current++;
+    const id = fetchIdRef.current;
+    setIsLoading(true);
+    try {
+      const result = await fetcher();
+      if (id !== fetchIdRef.current) return;
+      setData(result);
+      setError(null);
+      setLastUpdated(/* @__PURE__ */ new Date());
+    } catch (err) {
+      if (id !== fetchIdRef.current) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (id === fetchIdRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [fetcher]);
+  useEffect(() => {
+    if (!enabled) return;
+    void poll();
+    if (intervalMs <= 0) return;
+    const timer = setInterval(() => void poll(), intervalMs);
+    return () => clearInterval(timer);
+  }, [poll, intervalMs, enabled]);
+  const refetch = useCallback(() => {
+    void poll();
+  }, [poll]);
+  return { data, error, isLoading, lastUpdated, refetch };
+}
+
+// ../dashboard/src/hooks/use-consolidation-log.ts
+function useConsolidationLog(serverUrl, limit = 20, intervalMs = 3e4) {
+  const client = useMemo(() => new DashboardClient(serverUrl), [serverUrl]);
+  const fetcher = useCallback2(async () => {
+    const entries = await client.consolidationLog(limit);
+    return analyzeConsolidationLog(entries);
+  }, [client, limit]);
+  return usePolling(fetcher, { intervalMs });
+}
+
+// ../dashboard/src/hooks/use-knowledge-graph.ts
+import { useCallback as useCallback3, useMemo as useMemo2 } from "react";
+function useKnowledgeGraph(serverUrl, opts = {}) {
+  const { intervalMs = 3e4, limit = 50, minWeight, maxNodes } = opts;
+  const client = useMemo2(() => new DashboardClient(serverUrl), [serverUrl]);
+  const stableTransformOpts = useMemo2(
+    () => ({ minWeight, maxNodes }),
+    [minWeight, maxNodes]
+  );
+  const fetcher = useCallback3(async () => {
+    const { nodes, relationships } = await client.graphFull(limit);
+    return transformGraphData(nodes, relationships, stableTransformOpts);
+  }, [client, limit, stableTransformOpts]);
+  return usePolling(fetcher, { intervalMs });
+}
+
+// ../dashboard/src/hooks/use-memory-entries.ts
+import { useCallback as useCallback4, useMemo as useMemo3 } from "react";
+function useMemoryEntries(serverUrl, filters = {}, intervalMs = 0) {
+  const client = useMemo3(() => new DashboardClient(serverUrl), [serverUrl]);
+  const { page, limit, type, agentId, query } = filters;
+  const fetcher = useCallback4(
+    () => client.listEntriesPaginated({ page, limit, type, agentId, query }),
+    [client, page, limit, type, agentId, query]
+  );
+  return usePolling(fetcher, {
+    intervalMs: intervalMs ?? 3e4
+  });
+}
+
+// ../dashboard/src/hooks/use-memory-health.ts
+import { useCallback as useCallback5, useMemo as useMemo4 } from "react";
+function useMemoryHealth(serverUrl, intervalMs = 1e4) {
+  const client = useMemo4(() => new DashboardClient(serverUrl), [serverUrl]);
+  const fetcher = useCallback5(async () => {
+    try {
+      const raw = await client.fetchHealthRaw();
+      return enrichHealth(raw);
+    } catch (err) {
+      return unreachableHealth(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [client]);
+  return usePolling(fetcher, { intervalMs });
+}
+
+// ../dashboard/src/hooks/use-memory-stats.ts
+import { useCallback as useCallback6, useMemo as useMemo5 } from "react";
+function useMemoryStats(serverUrl, intervalMs = 5e3) {
+  const client = useMemo5(() => new DashboardClient(serverUrl), [serverUrl]);
+  const fetcher = useCallback6(() => client.stats(), [client]);
+  return usePolling(fetcher, { intervalMs });
+}
+
+// ../dashboard/src/hooks/use-type-distribution.ts
+import { useCallback as useCallback7, useMemo as useMemo6 } from "react";
+function useTypeDistribution(serverUrl, intervalMs = 15e3) {
+  const client = useMemo6(() => new DashboardClient(serverUrl), [serverUrl]);
+  const fetcher = useCallback7(async () => {
+    const entries = await client.listEntries({ limit: 100 });
+    return computeTypeDistribution(entries);
+  }, [client]);
+  return usePolling(fetcher, { intervalMs });
+}
+export {
+  DashboardClient,
+  Poller,
+  analyzeConsolidationLog,
+  computeMetrics,
+  computeTypeDistribution,
+  enrichHealth,
+  formatBytes,
+  formatUptime,
+  toD3ForceFormat,
+  toGraphologyFormat,
+  transformGraphData,
+  unreachableHealth,
+  useConsolidationLog,
+  useKnowledgeGraph,
+  useMemoryEntries,
+  useMemoryHealth,
+  useMemoryStats,
+  usePolling,
+  useTypeDistribution
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@pyxmate/memory",
+  "version": "0.0.1-beta",
+  "type": "module",
+  "description": "SDK for pyx-memory — Memory as a Service for AI agents",
+  "license": "MIT",
+  "sideEffects": false,
+  "keywords": [
+    "memory",
+    "ai",
+    "rag",
+    "agents",
+    "knowledge-graph",
+    "vector-search",
+    "maas"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fysoul17/pyx-memory.git",
+    "directory": "packages/sdk"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./dashboard": {
+      "import": "./dist/dashboard.mjs",
+      "types": "./dist/dashboard.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react.mjs",
+      "types": "./dist/react.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist node_modules .turbo"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "react": "^19.2.4",
+    "tsup": "^8.4.0"
+  }
+}