mnemocyte 0.0.8 → 0.1.0

package/README.md

@@ -52,6 +52,12 @@ explain: true,
 await client.close();
 ```
 
+See also: [Provider resilience](#provider-resilience),
+[Pruning memories](#pruning-memories),
+[Finding duplicates](#finding-duplicates-experimental),
+[Audit log](#audit-log-experimental), and
+[Consolidating duplicates](#consolidating-duplicates-experimental).
+
 ## Postgres usage
 
 Run the included migration against a Postgres database with pgvector enabled, then pass `databaseUrl`:
@@ -59,12 +65,18 @@ Run the included migration against a Postgres database with pgvector enabled, th
 ```ts
 const client = createMnemocyte({
 databaseUrl: process.env.DATABASE_URL,
-embedder,
+embedder, // embedder.dimensions MUST be 1536 — see below
 });
 ```
 
 The published package includes `migrations/0000_initial.sql`.
 
+> **Embedding dimensionality is pinned to 1536 on the Postgres backend.**
+> The bundled migration creates `embedding vector(1536)`. If
+> `embedder.dimensions` is anything else, `createMnemocyte` throws a
+> `MnemocyteError` with code `"CONFIG"` *before* opening the connection
+> pool. The in-memory backend has no such constraint.
+
 ## Provider resilience
 
 Mnemocyte applies an optional timeout and retry policy to every outbound
@@ -127,6 +139,102 @@ console.log(preview.matchedCount);
 Available selectors: `entityId`, `expired`, `superseded`, `createdBefore`,
 `notAccessedSince`, `types`, `tags`, `maxImportance`. They AND together.
 
+## Finding duplicates (experimental)
+
+`findDuplicates` is a **read-only** scan that surfaces near-identical
+memories for one entity using pairwise cosine similarity. It is
+intentionally passive — nothing is deleted or modified — so callers can
+decide their own consolidation policy.
+
+```ts
+const pairs = await client.findDuplicates({
+entityId: "user_123",
+threshold: 0.95, // default 0.95
+limit: 50, // default 100, ordered by similarity desc
+});
+
+for (const { a, b, similarity } of pairs) {
+console.log(similarity.toFixed(3), a.content, "<>", b.content);
+}
+```
+
+Optional selectors: `types`, `tags` (both required on each pair member),
+`includeSuperseded`, `includeExpired`. Superseded and expired memories
+are excluded by default.
+
+> Part of Phase 6 (consolidation tooling). The API surface may change in
+> follow-up releases as conflict detection and active dedup land.
+
+## Audit log (experimental)
+
+When `audit.enabled` is `true`, Mnemocyte records an entry on every
+state-changing operation (`remember`, `forget`, `forgetAll`, `prune`).
+Read with `client.listAuditLog()`.
+
+```ts
+const client = createMnemocyte({
+embedder,
+audit: { enabled: true },
+});
+
+await client.remember({ entityId: "user_123", content: "Likes tea." });
+await client.prune({ entityId: "user_123", expired: true });
+
+const log = await client.listAuditLog({
+entityId: "user_123",
+limit: 100,
+});
+for (const event of log) {
+console.log(event.timestamp, event.description, event.metadata);
+}
+```
+
+Recorded `description` slugs:
+
+- `"memory.created"` — single insert; metadata: `{ memoryId, type, importance }`
+- `"memory.deleted"` — single `forget`; metadata: `{ memoryId }`
+- `"entity.cleared"` — `forgetAll`; metadata: `{ count }`
+- `"memory.pruned"` — real (non-dryRun) `prune` with an `entityId` selector; metadata: `{ count }`
+
+Audit entries are **sticky**: `forgetAll` no longer erases prior log
+entries — wiping an entity is itself a recorded `"entity.cleared"`
+event. Disable audit by leaving `audit.enabled` unset (the default);
+historical entries remain readable.
+
+> Part of Phase 6 (consolidation tooling). The API surface may change
+> as conflict detection and consolidation land.
+
+## Consolidating duplicates (experimental)
+
+`client.experimental.consolidate()` merges likely-duplicate memories
+into a single survivor. Each loser is marked `supersededBy = survivor.id`
+and excluded from `recall` by default. Tags are unioned onto the
+survivor unless `mergeTags: false`. Idempotent — already-superseded
+memories are skipped.
+
+Pair it with `findDuplicates` to build a complete dedup pipeline:
+
+```ts
+const pairs = await client.findDuplicates({
+entityId: "user_123",
+threshold: 0.97,
+});
+
+for (const { a, b } of pairs) {
+await client.experimental.consolidate({
+entityId: "user_123",
+survivorId: a.id,
+supersededIds: [b.id],
+});
+}
+```
+
+When `audit.enabled` is `true`, each newly superseded memory writes a
+`"memory.superseded"` audit event with metadata `{ memoryId, supersededBy }`.
+
+> The `experimental` namespace is intentionally unstable. Members may
+> change or move to the main client surface in future releases.
+
 ## Retrieval tuning
 
 ```ts

package/dist/index.d.mts

@@ -40,7 +40,7 @@ type MnemocyteBackend = "in-memory" | "postgres";
  * The set of public {@link MnemocyteClient} methods that emit
  * {@link MnemocyteObservation} events through {@link ObservabilityConfig.onEvent}.
  */
-type MnemocyteOperation = "remember" | "rememberMany" | "recall" | "buildContext" | "forget" | "forgetAll" | "prune" | "stats" | "close";
+type MnemocyteOperation = "remember" | "rememberMany" | "recall" | "buildContext" | "forget" | "forgetAll" | "prune" | "findDuplicates" | "listAuditLog" | "consolidate" | "stats" | "close";
 /**
  * Lifecycle phase of a {@link MnemocyteObservation}.
  *
@@ -149,6 +149,30 @@ interface MnemocyteConfig {
    * {@link ProviderResilienceConfig}.
    */
   provider?: ProviderResilienceConfig;
+  /**
+   * Audit-log configuration. When enabled, Mnemocyte records an
+   * {@link AuditEvent} for every state-changing operation
+   * (`remember`, `forget`, `forgetAll`, `prune`). Read with
+   * {@link MnemocyteClient.listAuditLog}.
+   *
+   * @experimental Part of Phase 6 (consolidation tooling).
+   */
+  audit?: AuditConfig;
+}
+/**
+ * Audit-log configuration. See {@link MnemocyteConfig.audit}.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling).
+ */
+interface AuditConfig {
+  /**
+   * Master switch for audit logging. When `false` (default), Mnemocyte
+   * neither writes nor relies on the audit log; existing log entries
+   * remain readable via {@link MnemocyteClient.listAuditLog}.
+   *
+   * @defaultValue `false`
+   */
+  enabled?: boolean;
 }
 /**
  * Pluggable embedding provider. Wraps an external embedding API
@@ -184,7 +208,7 @@ interface Embedder {
  * new memory and link the previous one via {@link Memory.supersededBy}.
  */
 interface Memory {
-  /** Unique identifier (UUID for Postgres backend). */
+  /** Unique identifier (`mem_*` prefixed string). */
   id: string;
   /** Owning entity — typically a user, agent, or session ID. */
   entityId: string;
@@ -208,6 +232,13 @@ interface Memory {
   embeddingDimensions: number;
   /** ID of the memory that supersedes this one, or `null` if active. */
   supersededBy: string | null;
+  /**
+   * Wall-clock time when this memory was superseded, or `null` if it
+   * has not been superseded. Set together with
+   * {@link Memory.supersededBy} by
+   * {@link ExperimentalMnemocyteClient.consolidate}.
+   */
+  supersededAt: Date | null;
   /** Optional expiry; expired memories are filtered out by default. */
   expiresAt: Date | null;
   /** Last time this memory was returned by {@link MnemocyteClient.recall}. */
@@ -476,6 +507,142 @@ interface PruneResult {
   /** `true` when {@link PruneInput.dryRun} was set. */
   dryRun: boolean;
 }
+/**
+ * Input for {@link MnemocyteClient.findDuplicates}.
+ *
+ * Performs a pairwise cosine-similarity scan of stored memories for a
+ * single entity and returns pairs whose similarity meets
+ * {@link FindDuplicatesInput.threshold}. The scan is read-only — no
+ * memories are modified or deleted.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling). API may change.
+ */
+interface FindDuplicatesInput {
+  /** Entity whose memories should be scanned for duplicates. */
+  entityId: string;
+  /**
+   * Cosine-similarity cutoff in `[0, 1]`. Pairs whose similarity is at
+   * or above this value are returned. @defaultValue `0.95`
+   */
+  threshold?: number;
+  /**
+   * Maximum number of duplicate pairs to return, ordered by descending
+   * similarity. @defaultValue `100`
+   */
+  limit?: number;
+  /** Restrict the scan to these memory types. */
+  types?: readonly MemoryType[];
+  /** Require both memories in the pair to include all of these tags. */
+  tags?: readonly string[];
+  /** Include superseded memories in the scan. @defaultValue `false` */
+  includeSuperseded?: boolean;
+  /** Include expired memories in the scan. @defaultValue `false` */
+  includeExpired?: boolean;
+  /** Optional cancellation signal. */
+  signal?: AbortSignal;
+}
+/**
+ * A pair of memories that are likely duplicates.
+ *
+ * The pair is unordered (i.e. `{a, b}` is the same logical result as
+ * `{b, a}`); Mnemocyte returns each pair only once.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling). Shape may change.
+ */
+interface DuplicatePair {
+  /** One of the two memories in the duplicate pair. */
+  a: Memory;
+  /** The other memory in the duplicate pair. */
+  b: Memory;
+  /** Cosine similarity between the two embeddings, in `[0, 1]`. */
+  similarity: number;
+}
+/**
+ * A single audit-log entry recording a state-changing operation.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling).
+ */
+interface AuditEvent {
+  /** Unique identifier (`evt_*` prefixed string). */
+  id: string;
+  /** Entity whose state was changed. */
+  entityId: string;
+  /**
+   * Stable, dotted slug describing the change. Examples:
+   * `"memory.created"`, `"memory.deleted"`, `"memory.pruned"`,
+   * `"entity.cleared"`.
+   */
+  description: string;
+  /** Free-form structured details about the change. */
+  metadata: Record<string, unknown>;
+  /** When the change was recorded. */
+  timestamp: Date;
+}
+/**
+ * Input for {@link MnemocyteClient.listAuditLog}.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling).
+ */
+interface ListAuditLogInput {
+  /** Entity whose audit log should be returned. */
+  entityId: string;
+  /**
+   * Maximum number of entries to return, ordered newest first.
+   * @defaultValue `50`
+   */
+  limit?: number;
+  /** Only return entries strictly before this timestamp. */
+  before?: Date;
+  /** Only return entries strictly after this timestamp. */
+  after?: Date;
+  /** Optional cancellation signal. */
+  signal?: AbortSignal;
+}
+/**
+ * Input for {@link ExperimentalMnemocyteClient.consolidate}.
+ *
+ * Marks each memory in {@link ConsolidateInput.supersededIds} as
+ * superseded by {@link ConsolidateInput.survivorId}. Optionally
+ * unions the losers' tags into the survivor.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling).
+ */
+interface ConsolidateInput {
+  /** Entity that owns every memory referenced. */
+  entityId: string;
+  /** Memory that should win the merge. Must not itself be superseded. */
+  survivorId: string;
+  /**
+   * Memories to mark as superseded by the survivor. Already-superseded
+   * entries in this list are skipped silently for idempotency. Must
+   * not contain {@link ConsolidateInput.survivorId}.
+   */
+  supersededIds: readonly string[];
+  /**
+   * When `true`, the survivor's `tags` becomes the union of its own
+   * tags and the tags of every memory that was actually superseded.
+   * @defaultValue `true`
+   */
+  mergeTags?: boolean;
+  /** Optional cancellation signal. */
+  signal?: AbortSignal;
+}
+/**
+ * Result returned by {@link ExperimentalMnemocyteClient.consolidate}.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling).
+ */
+interface ConsolidateResult {
+  /** Echoes {@link ConsolidateInput.survivorId}. */
+  survivorId: string;
+  /**
+   * Number of memories actually marked as superseded. Excludes entries
+   * that were already superseded (idempotent skip).
+   */
+  supersededCount: number;
+  /** The IDs that were newly superseded during this call. */
+  supersededIds: readonly string[];
+}
 /**
  * Stats for a single entity, returned by
  * {@link MnemocyteClient.stats} when an `entityId` is provided.
@@ -572,6 +739,55 @@ interface MnemocyteClient {
    * ```
    */
   prune(input: PruneInput): Promise<PruneResult>;
+  /**
+   * Scan an entity's memories for likely duplicates by pairwise cosine
+   * similarity and return matching pairs, ordered by descending
+   * similarity. Read-only — no memories are modified.
+   *
+   * @experimental Part of Phase 6 (consolidation tooling). API may change.
+   *
+   * @example
+   * ```ts
+   * const pairs = await client.findDuplicates({
+   *   entityId: "user_123",
+   *   threshold: 0.95,
+   *   limit: 50,
+   * });
+   * for (const { a, b, similarity } of pairs) {
+   *   console.log(similarity, a.content, "<>", b.content);
+   * }
+   * ```
+   */
+  findDuplicates(input: FindDuplicatesInput): Promise<DuplicatePair[]>;
+  /**
+   * Return audit-log entries for `entityId`, newest first.
+   *
+   * Entries are recorded automatically when
+   * {@link MnemocyteConfig.audit}.`enabled` is `true`. Historic entries
+   * remain readable even after toggling `enabled` back to `false`.
+   *
+   * @experimental Part of Phase 6 (consolidation tooling). API may change.
+   *
+   * @example
+   * ```ts
+   * const log = await client.listAuditLog({
+   *   entityId: "user_123",
+   *   limit: 100,
+   * });
+   * for (const event of log) {
+   *   console.log(event.timestamp, event.description, event.metadata);
+   * }
+   * ```
+   */
+  listAuditLog(input: ListAuditLogInput): Promise<AuditEvent[]>;
+  /**
+   * Unstable, opt-in extension surface. Members may change or be
+   * removed without a semver bump until they graduate to the main
+   * client interface.
+   *
+   * @experimental Part of Phase 6 (consolidation tooling).
+   */
+  experimental: ExperimentalMnemocyteClient;
   /**
    * Return statistics. With an `entityId`, returns {@link EntityStats};
    * without one, returns {@link GlobalStats}.
@@ -585,6 +801,45 @@ interface MnemocyteClient {
    */
   close(): Promise<void>;
 }
+/**
+ * Extension surface for unstable Phase 6 operations. Reached via
+ * {@link MnemocyteClient.experimental}.
+ *
+ * @experimental Members may change or be removed without a semver bump.
+ */
+interface ExperimentalMnemocyteClient {
+  /**
+   * Consolidate likely-duplicate memories into a single survivor by
+   * marking the others as superseded. Optionally unions their tags
+   * onto the survivor. Idempotent for memories that are already
+   * superseded.
+   *
+   * Emits one `"memory.superseded"` audit event per newly superseded
+   * memory when {@link MnemocyteConfig.audit}.`enabled` is `true`.
+   *
+   * @experimental Part of Phase 6 (consolidation tooling). API may change.
+   *
+   * @throws {MnemocyteError} `"VALIDATION"` for empty `supersededIds`,
+   * a `survivorId` that also appears in `supersededIds`, or a survivor
+   * that is itself already superseded.
+   * @throws {MnemocyteError} `"NOT_FOUND"` if the survivor or any
+   * non-already-superseded memory in `supersededIds` does not belong
+   * to `entityId`.
+   *
+   * @example
+   * ```ts
+   * const pairs = await client.findDuplicates({ entityId: "user_123" });
+   * for (const { a, b } of pairs) {
+   *   await client.experimental.consolidate({
+   *     entityId: "user_123",
+   *     survivorId: a.id,
+   *     supersededIds: [b.id],
+   *   });
+   * }
+   * ```
+   */
+  consolidate(input: ConsolidateInput): Promise<ConsolidateResult>;
+}
 //#endregion
 //#region src/client.d.ts
 /**
@@ -601,14 +856,16 @@ interface MnemocyteClient {
  *
  * @param config - Client configuration. {@link MnemocyteConfig.embedder} is required.
  * @returns A {@link MnemocyteClient} instance.
- * @throws {MnemocyteError} With code `"CONFIG"` if `embedder` is missing or invalid,
- * or `"VALIDATION"` if `databaseUrl` is provided but empty.
+ * @throws {MnemocyteError} With code `"CONFIG"` if `embedder` is missing or
+ * invalid (including when `databaseUrl` is set and `embedder.dimensions`
+ * is not 1536 — the dimensionality pinned by the bundled migration), or
+ * `"VALIDATION"` if `databaseUrl` is provided but empty.
  *
  * @example Postgres-backed client
  * ```ts
  * const client = createMnemocyte({
  *   databaseUrl: process.env.DATABASE_URL,
- *   embedder,
+ *   embedder, // embedder.dimensions MUST be 1536 for the Postgres backend
  * });
  * ```
  */
@@ -670,5 +927,5 @@ declare class MnemocyteError extends Error {
  */
 declare function isMnemocyteError(error: unknown): error is MnemocyteError;
 //#endregion
-export { type BuildContextInput, type ContextFormat, type Embedder, type EntityStats, type GlobalStats, type ImportanceLevel, type Memory, type MemoryType, type MemoryWithScore, type MnemocyteBackend, type MnemocyteClient, type MnemocyteConfig, MnemocyteError, type MnemocyteErrorCode, type MnemocyteObservation, type MnemocyteObservationPhase, type MnemocyteOperation, type ObservabilityConfig, type ProviderResilienceConfig, type PruneInput, type PruneResult, type RecallInput, type RememberInput, type RetrievalConfig, type RetrievalExplanation, type RetrievalScoreWeights, type RetrievalScores, type TokenCounter, createMnemocyte, isMnemocyteError };
+export { type AuditConfig, type AuditEvent, type BuildContextInput, type ConsolidateInput, type ConsolidateResult, type ContextFormat, type DuplicatePair, type Embedder, type EntityStats, type ExperimentalMnemocyteClient, type FindDuplicatesInput, type GlobalStats, type ImportanceLevel, type ListAuditLogInput, type Memory, type MemoryType, type MemoryWithScore, type MnemocyteBackend, type MnemocyteClient, type MnemocyteConfig, MnemocyteError, type MnemocyteErrorCode, type MnemocyteObservation, type MnemocyteObservationPhase, type MnemocyteOperation, type ObservabilityConfig, type ProviderResilienceConfig, type PruneInput, type PruneResult, type RecallInput, type RememberInput, type RetrievalConfig, type RetrievalExplanation, type RetrievalScoreWeights, type RetrievalScores, type TokenCounter, createMnemocyte, isMnemocyteError };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts"],"mappings":"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"}