@pyxmate/memory 1.26.6 → 1.27.1

package/dist/mcp-install-KBB45OB2.mjs

@@ -0,0 +1,36 @@
+import {
+  installMemoryRules,
+  installMemoryRulesOnly,
+  mcpInstallClaudeCodeCommand,
+  mcpInstallClineCommand,
+  mcpInstallCodexCommand,
+  mcpInstallContinueCommand,
+  mcpInstallCursorCommand,
+  mcpInstallGeminiCliCommand,
+  mcpInstallHermesCommand,
+  mcpInstallOhMyPiCommand,
+  mcpInstallOpenClawCommand,
+  mcpInstallPiCommand,
+  mcpInstallWindsurfCommand,
+  reconcileMemoryRules,
+  syncMemoryRulesFromServer
+} from "./chunk-QR5K7ETI.mjs";
+import "./chunk-QD7G23CN.mjs";
+import "./chunk-4DXEQC6X.mjs";
+export {
+  installMemoryRules,
+  installMemoryRulesOnly,
+  mcpInstallClaudeCodeCommand,
+  mcpInstallClineCommand,
+  mcpInstallCodexCommand,
+  mcpInstallContinueCommand,
+  mcpInstallCursorCommand,
+  mcpInstallGeminiCliCommand,
+  mcpInstallHermesCommand,
+  mcpInstallOhMyPiCommand,
+  mcpInstallOpenClawCommand,
+  mcpInstallPiCommand,
+  mcpInstallWindsurfCommand,
+  reconcileMemoryRules,
+  syncMemoryRulesFromServer
+};

package/dist/overview-COBXHLP3.mjs

@@ -0,0 +1,88 @@
+import {
+  readSurface
+} from "./chunk-UESIQ47D.mjs";
+import "./chunk-THLUBOGD.mjs";
+import "./chunk-7TATCSSN.mjs";
+import {
+  EXIT
+} from "./chunk-4DXEQC6X.mjs";
+
+// src/cli/commands/overview.ts
+import { z } from "zod";
+var OVERVIEW_SCHEMA_VERSION = 1;
+var RECENT_ENTRY_LIMIT = 3;
+var MAX_TOPIC_CHARS = 160;
+var MAX_PROJECT_CHARS = 80;
+var entrySchema = z.object({
+  id: z.string().min(1),
+  metadata: z.record(z.string(), z.unknown())
+}).passthrough();
+var hostedEntriesResponseSchema = z.object({
+  memories: z.array(entrySchema),
+  total: z.number().int().nonnegative()
+}).passthrough();
+var selfHostedEntriesResponseSchema = z.object({
+  success: z.literal(true),
+  data: z.object({
+    entries: z.array(entrySchema),
+    totalCount: z.number().int().nonnegative()
+  }).passthrough()
+}).passthrough();
+var entriesResponseSchema = z.union([
+  hostedEntriesResponseSchema.transform(({ memories, total }) => ({
+    entries: memories,
+    totalCount: total
+  })),
+  selfHostedEntriesResponseSchema.transform(({ data }) => data)
+]);
+async function overviewCommand(opts = {}) {
+  const result = await readSurface({
+    surface: "overview",
+    request: {
+      method: "GET",
+      path: "/api/memory/entries",
+      query: { status: "active", limit: RECENT_ENTRY_LIMIT }
+    },
+    schema: entriesResponseSchema,
+    keychain: opts.keychain,
+    fetchImpl: opts.fetchImpl
+  });
+  if (!result.ok) {
+    emit(report(result.state, result.endpoint, result.keySource, result.problem));
+    return result.exit;
+  }
+  emit({
+    ...report("ready", result.endpoint, "keychain", null),
+    totalCount: result.data.totalCount,
+    entries: result.data.entries.slice(0, RECENT_ENTRY_LIMIT).map((entry) => ({
+      id: entry.id,
+      topic: boundedLabel(entry.metadata.topic, "Untitled", MAX_TOPIC_CHARS),
+      project: boundedLabel(entry.metadata.project, "Unscoped", MAX_PROJECT_CHARS)
+    }))
+  });
+  return EXIT.OK;
+}
+function report(state, endpoint, keySource, problem) {
+  return {
+    schemaVersion: OVERVIEW_SCHEMA_VERSION,
+    state,
+    endpoint,
+    keySource,
+    totalCount: 0,
+    entries: [],
+    problem
+  };
+}
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+function boundedLabel(value, fallback, maxChars) {
+  if (typeof value !== "string" || value.trim().length === 0) return fallback;
+  const normalized = value.trim();
+  const chars = [...normalized];
+  return chars.length > maxChars ? `${chars.slice(0, maxChars).join("")}\u2026` : normalized;
+}
+export {
+  overviewCommand
+};

package/dist/react.mjs

@@ -13,7 +13,7 @@ import {
   unreachableHealth
 } from "./chunk-N4KDRRLY.mjs";
 import "./chunk-M67SXB7C.mjs";
-import "./chunk-KZKGRND2.mjs";
+import "./chunk-RWQTBXUC.mjs";
 import "./chunk-HTQBKJTD.mjs";
 
 // ../dashboard/src/hooks/use-consolidation-log.ts

package/dist/scaffold-2FSCWF22.mjs

@@ -0,0 +1,186 @@
+import {
+  buildDesignGuide
+} from "./chunk-QD7G23CN.mjs";
+import {
+  EXIT
+} from "./chunk-4DXEQC6X.mjs";
+
+// src/cli/commands/scaffold.ts
+import { existsSync, mkdirSync, statSync, writeFileSync } from "fs";
+import { basename, join, resolve } from "path";
+var SERVER_IMAGE = "ghcr.io/pyx-corp/pyx-memory-v1:latest";
+var DOCKER_COMPOSE = `services:
+  pyx-memory:
+    image: ${SERVER_IMAGE}
+    ports:
+      - "7822:7822"
+    volumes:
+      - pyx-memory-data:/data
+    environment:
+      DATA_DIR: "\${DATA_DIR:-/data}"
+      API_KEY: "\${API_KEY:-}"
+      ADMIN_API_KEY: "\${ADMIN_API_KEY:-}"
+      TENANT_MODE: "\${TENANT_MODE:-single}"
+      NEO4J_URL: "\${NEO4J_URL:-bolt://neo4j:7687}"
+      NEO4J_USERNAME: "\${NEO4J_USERNAME:-neo4j}"
+      NEO4J_PASSWORD: "\${NEO4J_PASSWORD:?Set NEO4J_PASSWORD in .env or the shell.}"
+      EMBEDDING_PROVIDER: "\${EMBEDDING_PROVIDER:-local}"
+      EMBEDDING_ENDPOINT: "\${EMBEDDING_ENDPOINT:-}"
+      EMBEDDING_DIMENSIONS: "\${EMBEDDING_DIMENSIONS:-}"
+      # Graph is built by the CALLING AGENT by default (it passes entities +
+      # relationships / triples) \u2014 the server runs no LLM. To opt into
+      # server-side BYO extraction, set EXTRACTION_PROVIDER=http and supply
+      # EXTRACTION_ENDPOINT in .env.
+      EXTRACTION_PROVIDER: "\${EXTRACTION_PROVIDER:-none}"
+      EXTRACTION_ENDPOINT: "\${EXTRACTION_ENDPOINT:-}"
+      EXTRACTION_API_KEY: "\${EXTRACTION_API_KEY:-}"
+      EXTRACTION_MODEL: "\${EXTRACTION_MODEL:-}"
+      ENCRYPTION_KEY: "\${ENCRYPTION_KEY:-}"
+    depends_on:
+      neo4j:
+        condition: service_healthy
+
+  neo4j:
+    image: neo4j:5-community
+    ports:
+      - "7474:7474"
+      - "7687:7687"
+    volumes:
+      - pyx-memory-neo4j-data:/data
+      - pyx-memory-neo4j-logs:/logs
+    environment:
+      NEO4J_AUTH: "neo4j/\${NEO4J_PASSWORD:?Set NEO4J_PASSWORD in .env or the shell.}"
+      NEO4J_PLUGINS: '["apoc"]'
+    healthcheck:
+      test: ["CMD", "neo4j", "status"]
+      interval: 10s
+      timeout: 10s
+      retries: 10
+
+volumes:
+  pyx-memory-data:
+  pyx-memory-neo4j-data:
+  pyx-memory-neo4j-logs:
+`;
+var ENV_EXAMPLE = `# pyx-memory operator config
+# Copy this file to .env, then fill the required values before running Docker Compose.
+
+# OPTIONAL. Graph is built by the calling agent by default (the server runs no LLM).
+# Set to http ONLY to opt into server-side BYO entity/relationship extraction.
+EXTRACTION_PROVIDER=none
+
+# REQUIRED only when EXTRACTION_PROVIDER=http. HTTP chat/completions-compatible base URL.
+# Leave empty for the default agent-owns-the-graph setup.
+EXTRACTION_ENDPOINT=
+
+# OPTIONAL. Bearer token sent to EXTRACTION_ENDPOINT when your extraction service requires auth.
+EXTRACTION_API_KEY=
+
+# OPTIONAL. Model identifier sent to the extraction service.
+EXTRACTION_MODEL=
+
+# OPTIONAL for local embeddings. Set to http only when using a remote embedding service.
+EMBEDDING_PROVIDER=local
+
+# REQUIRED only when EMBEDDING_PROVIDER=http. Base URL for the HTTP embedding service.
+EMBEDDING_ENDPOINT=
+
+# REQUIRED only when EMBEDDING_PROVIDER=http. Must match the remote embedding vector width.
+# Example for embeddinggemma: 768.
+EMBEDDING_DIMENSIONS=
+
+# RECOMMENDED for any protected or production deployment. Empty means unauthenticated local access.
+API_KEY=
+
+# OPTIONAL. Destructive/admin operations use this; when empty, the server falls back to API_KEY.
+ADMIN_API_KEY=
+
+# REQUIRED only when SENSITIVITY_POLICY=encrypt is configured on the server.
+# 32 bytes as 64 hex chars or 44 base64 chars.
+ENCRYPTION_KEY=
+
+# REQUIRED by the scaffolded container.
+DATA_DIR=/data
+
+# REQUIRED. Use single for one app/tenant; use multi only behind authenticated tenant routing.
+TENANT_MODE=single
+
+# REQUIRED for graph storage in this compose stack.
+NEO4J_URL=bolt://neo4j:7687
+
+# OPTIONAL. Defaults to neo4j when unset.
+NEO4J_USERNAME=neo4j
+
+# REQUIRED by docker-compose.yml for the Neo4j service and pyx-memory graph connection.
+NEO4J_PASSWORD=
+`;
+var MEMORY_TS = `import { createPyxMemory } from '@pyxmate/memory';
+
+// Reads PYX_MEMORY_URL and PYX_MEMORY_API_KEY by default.
+export const memory = createPyxMemory();
+`;
+function resolveTarget(args) {
+  const cwd = args.cwd ?? process.cwd();
+  if (args.name === true) {
+    process.stderr.write("Error: --name requires a directory name.\n");
+    return null;
+  }
+  const trimmedName = typeof args.name === "string" ? args.name.trim() : "";
+  if (typeof args.name === "string" && trimmedName.length === 0) {
+    process.stderr.write("Error: --name requires a non-empty directory name.\n");
+    return null;
+  }
+  const targetDir = trimmedName ? resolve(cwd, trimmedName) : cwd;
+  const appName = trimmedName || basename(resolve(cwd));
+  return { targetDir, appName };
+}
+function buildFiles(targetDir, appName) {
+  return [
+    { path: join(targetDir, "docker-compose.yml"), contents: DOCKER_COMPOSE },
+    { path: join(targetDir, ".env.example"), contents: ENV_EXAMPLE },
+    { path: join(targetDir, "memory.ts"), contents: MEMORY_TS },
+    {
+      path: join(targetDir, "PYX_MEMORY_DESIGN_GUIDE.md"),
+      contents: buildDesignGuide({ appName })
+    }
+  ];
+}
+function scaffoldCommand(args = {}) {
+  const target = resolveTarget(args);
+  if (target === null) return EXIT.USAGE;
+  if (existsSync(target.targetDir) && !statSync(target.targetDir).isDirectory()) {
+    process.stderr.write(`Error: target exists and is not a directory: ${target.targetDir}
+`);
+    return EXIT.USAGE;
+  }
+  mkdirSync(target.targetDir, { recursive: true });
+  const created = [];
+  const skipped = [];
+  for (const file of buildFiles(target.targetDir, target.appName)) {
+    const relativePath = basename(file.path);
+    if (existsSync(file.path)) {
+      skipped.push(relativePath);
+      continue;
+    }
+    writeFileSync(file.path, file.contents, "utf8");
+    created.push(relativePath);
+  }
+  process.stdout.write(
+    [
+      `pyx-memory scaffold: ${target.targetDir}`,
+      `created: ${created.length > 0 ? created.join(", ") : "(none)"}`,
+      `skipped: ${skipped.length > 0 ? skipped.join(", ") : "(none)"}`,
+      "",
+      "Next steps:",
+      "1. Copy .env.example to .env and set NEO4J_PASSWORD (graph is built by the calling agent by default \u2014 set EXTRACTION_* only to opt into server-side BYO extraction).",
+      "2. Set API_KEY before using this beyond local development.",
+      "3. Run: docker compose up -d",
+      "4. Set PYX_MEMORY_URL=http://localhost:7822 and PYX_MEMORY_API_KEY to match API_KEY.",
+      ""
+    ].join("\n")
+  );
+  return EXIT.OK;
+}
+export {
+  scaffoldCommand
+};

package/dist/status-UHJZLEPL.mjs

@@ -0,0 +1,74 @@
+import {
+  JournalInvalidError,
+  KeychainError,
+  convergenceSeconds,
+  credentialFingerprint,
+  getDefaultKeychain,
+  guardKeychain,
+  isEmpty,
+  loadJournal
+} from "./chunk-7TATCSSN.mjs";
+import {
+  EXIT
+} from "./chunk-4DXEQC6X.mjs";
+
+// src/cli/commands/status.ts
+async function readLifecycle(provider) {
+  let serverConvergenceSeconds = null;
+  try {
+    const journal = await loadJournal(provider);
+    serverConvergenceSeconds = convergenceSeconds(journal);
+    if (isEmpty(journal)) return { cleanupPending: false, serverConvergenceSeconds };
+  } catch (err) {
+    if (!(err instanceof JournalInvalidError)) throw err;
+  }
+  return { cleanupPending: !await provider.isLocked(), serverConvergenceSeconds };
+}
+async function statusCommand(opts = {}) {
+  const provider = opts.keychain ? guardKeychain(opts.keychain) : getDefaultKeychain();
+  let report;
+  try {
+    const creds = await provider.read();
+    report = {
+      endpoint: creds?.endpoint ?? null,
+      keyPresent: creds !== null,
+      keySource: creds !== null ? "keychain" : null,
+      loggedIn: creds !== null,
+      credentialFingerprint: creds === null ? null : credentialFingerprint(creds.endpoint, creds.apiKey),
+      lifecycleVersion: 1,
+      connection: creds?.provenance === "browser-login" ? creds.connection ?? null : null,
+      ...await readLifecycle(provider)
+    };
+  } catch (err) {
+    if (err instanceof KeychainError) return emitError(err, opts.json);
+    throw err;
+  }
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report)}
+`);
+  } else {
+    const lines = [
+      `endpoint:    ${report.endpoint ?? "(not set)"}`,
+      `credentials: ${report.loggedIn ? "present (keychain)" : "not logged in \u2014 run: pyx-mem login"}`
+    ];
+    process.stdout.write(`${lines.join("\n")}
+`);
+  }
+  return report.loggedIn ? EXIT.OK : EXIT.NOT_LOGGED_IN;
+}
+function emitError(err, json) {
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: false, code: err.code, message: err.message, guidance: err.guidance })}
+`
+    );
+  } else {
+    process.stderr.write(`Error: ${err.message}
+${err.guidance}
+`);
+  }
+  return err.exit;
+}
+export {
+  statusCommand
+};

package/dist/taxonomy-EKDFDFXW.mjs

@@ -0,0 +1,103 @@
+import {
+  readSurface
+} from "./chunk-UESIQ47D.mjs";
+import "./chunk-THLUBOGD.mjs";
+import "./chunk-7TATCSSN.mjs";
+import {
+  MEMORY_PROJECT_LABEL_MAX_CHARS,
+  TAXONOMY_MAX_CATEGORIES,
+  TAXONOMY_MAX_PROJECTS,
+  TAXONOMY_MAX_SAMPLE_TOPICS,
+  TAXONOMY_MAX_TOP_ENTITIES
+} from "./chunk-RWQTBXUC.mjs";
+import "./chunk-HTQBKJTD.mjs";
+import {
+  EXIT
+} from "./chunk-4DXEQC6X.mjs";
+
+// src/cli/commands/taxonomy.ts
+import { z } from "zod";
+var TAXONOMY_SCHEMA_VERSION = 1;
+var TAXONOMY_MAX_RETURNED_CATEGORIES = TAXONOMY_MAX_CATEGORIES + 1;
+var taxonomyStateSchema = z.object({
+  clusters: z.array(
+    z.object({
+      size: z.number().int().nonnegative(),
+      currentName: z.string().nullable(),
+      categoryNodeId: z.string().nullable(),
+      projects: z.array(
+        z.object({
+          name: z.string().min(1).max(MEMORY_PROJECT_LABEL_MAX_CHARS),
+          memories: z.number().int().positive()
+        })
+      ).max(TAXONOMY_MAX_PROJECTS),
+      sampleTopics: z.array(z.string()).max(TAXONOMY_MAX_SAMPLE_TOPICS),
+      topEntities: z.array(
+        z.object({
+          name: z.string(),
+          type: z.string(),
+          degree: z.number().int().nonnegative()
+        })
+      ).max(TAXONOMY_MAX_TOP_ENTITIES)
+    })
+  ).max(TAXONOMY_MAX_RETURNED_CATEGORIES),
+  totals: z.object({
+    clusters: z.number().int().nonnegative(),
+    unnamed: z.number().int().nonnegative(),
+    nodesConsidered: z.number().int().nonnegative()
+  })
+});
+var taxonomyResponseSchema = z.union([
+  taxonomyStateSchema,
+  z.object({ success: z.literal(true), data: taxonomyStateSchema }).transform(({ data }) => data)
+]);
+async function taxonomyCommand(opts = {}) {
+  const result = await readSurface({
+    surface: "taxonomy",
+    request: { method: "GET", path: "/api/memory/graph/taxonomy" },
+    schema: taxonomyResponseSchema,
+    minimumServiceVersion: "1.18.1",
+    keychain: opts.keychain,
+    fetchImpl: opts.fetchImpl
+  });
+  const withIdentity = opts.withIdentity === true;
+  if (!result.ok) {
+    emit(
+      report(result.state, result.endpoint, result.keySource, result.problem, {
+        withIdentity,
+        credentialFingerprint: result.credentialFingerprint
+      })
+    );
+    return result.exit;
+  }
+  emit({
+    ...report("ready", result.endpoint, "keychain", null, {
+      withIdentity,
+      credentialFingerprint: result.credentialFingerprint
+    }),
+    clusters: result.data.clusters,
+    totals: result.data.totals
+  });
+  return EXIT.OK;
+}
+function report(state, endpoint, keySource, problem, identity) {
+  return {
+    schemaVersion: TAXONOMY_SCHEMA_VERSION,
+    state,
+    endpoint,
+    keySource,
+    // Spread, not `undefined`: JSON.stringify would drop an undefined value,
+    // but the key must be absent from the object too so exact-shape checks hold.
+    ...identity.withIdentity ? { credentialFingerprint: identity.credentialFingerprint } : {},
+    clusters: [],
+    totals: { clusters: 0, unnamed: 0, nodesConsidered: 0 },
+    problem
+  };
+}
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+export {
+  taxonomyCommand
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "1.26.6",
+  "version": "1.27.1",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",