@fgv/ts-agent-memory 5.1.0-36

package/lib/packlets/store/fileTreeMemoryStore.d.ts

@@ -0,0 +1,327 @@
+import { Logging, Result } from '@fgv/ts-utils';
+import { FileTree } from '@fgv/ts-json-base';
+import { EntityId, IIdentityCodec, IMemoryRecord, IWritePolicy, Kind, MemoryId, MemoryScopeKey, Tag } from '../types';
+import { IBodyConverterRegistry as IRegistry } from '../converters';
+import { IMemoryObserver } from '../observe';
+import { IVectorIndex, MemoryEmbedder } from '../vector';
+/**
+ * Filter for {@link IMemoryStore.list}. All present fields are ANDed together.
+ * @public
+ */
+export interface IMemoryStoreListFilter {
+    /** Restrict to records in this scope. */
+    readonly scope?: MemoryScopeKey;
+    /** Restrict to records of this kind. */
+    readonly kind?: Kind;
+    /** Restrict to records carrying this tag (exact match). */
+    readonly tag?: Tag;
+    /**
+     * For temporal kinds: return only records valid at this epoch ms. No-op in
+     * B1 (no temporal kinds wired).
+     */
+    readonly asOf?: number;
+}
+/**
+ * The writable, FileTree-backed, content-hash-deduped memory store.
+ * @public
+ */
+export interface IMemoryStore {
+    /**
+     * Keyed read by entity id. Resolves `entityId` to a storage address via the
+     * registered {@link IIdentityCodec} for `kind`. Returns `undefined` when no
+     * record exists.
+     */
+    get(kind: Kind, entityId: EntityId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    /**
+     * Direct read by `(scope, MemoryId)`. Returns `undefined` when not found.
+     */
+    getById(scope: MemoryScopeKey, id: MemoryId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    /**
+     * List records, filtered in-memory over the derived index.
+     */
+    list(filter?: IMemoryStoreListFilter): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    /**
+     * Write a record. Validates the body, computes a content hash, deduplicates
+     * (scope-wide, before policy), applies the kind's {@link IWritePolicy}, stamps
+     * transaction-time metadata (`created` / `updated` / `seq` / `contentHash`),
+     * writes the file, and patches the index. Returns the written record — or the
+     * existing record unchanged on a dedup no-op.
+     */
+    put(record: IMemoryRecord<unknown>): Promise<Result<IMemoryRecord<unknown>>>;
+    /**
+     * Delete a record by `(kind, entityId)`. Non-temporal kinds physically delete
+     * the file. Returns the {@link MemoryId} of the deleted record.
+     */
+    delete(kind: Kind, entityId: EntityId): Promise<Result<MemoryId>>;
+}
+/**
+ * Parameters for {@link FileTreeMemoryStore.create}.
+ * @public
+ */
+export interface IFileTreeMemoryStoreCreateParams {
+    /** Root directory under which scope-encoded sub-trees live. Must be mutable. */
+    readonly root: FileTree.IMutableFileTreeDirectoryItem;
+    /** Per-kind body converter registry. Gates every body on write and read. */
+    readonly registry: IRegistry;
+    /** Per-kind write policies. Kinds without an entry use a default LWW policy. */
+    readonly writePolicies?: ReadonlyMap<Kind, IWritePolicy>;
+    /** Per-kind identity codecs. */
+    readonly codecs?: ReadonlyMap<Kind, IIdentityCodec>;
+    /** Default codec for kinds without an explicit entry. */
+    readonly defaultCodec?: IIdentityCodec;
+    /** Scope encoding. Defaults to {@link defaultMemoryScopeEncoding}. */
+    readonly scopeEncoding?: (scope: MemoryScopeKey) => Result<string>;
+    /**
+     * Transaction-time clock. Defaults to `Date.now`. Injectable so tests can
+     * make `created` / `updated` deterministic. Also stamps observation
+     * `timestamp`s.
+     */
+    readonly clock?: () => number;
+    /**
+     * Optional observers fired once per public `get` / `put` / `delete` call.
+     * Purely additive — when absent, no observation records are produced and the
+     * store behaves exactly as it did without this parameter. Observer errors
+     * never affect the store operation (swallowed, logged to {@link
+     * IFileTreeMemoryStoreCreateParams.logger | logger} at `warn`).
+     */
+    readonly observers?: ReadonlyArray<IMemoryObserver>;
+    /**
+     * Diagnostic logger for swallowed observer failures. Defaults to a
+     * `Logging.NoOpLogger`.
+     */
+    readonly logger?: Logging.ILogger;
+    /**
+     * Optional vector index for semantic recall. Wired together with
+     * {@link IFileTreeMemoryStoreCreateParams.embed | embed}: when both are present
+     * the store embeds each written record and maintains the index on
+     * `put` / `delete` / cap-cull eviction. Absent (or `embed` absent) → no
+     * embedding work happens and the store behaves exactly as it does without this
+     * parameter (the additive, zero-overhead-when-unwired default — mirrors the
+     * observer hook).
+     */
+    readonly vectorIndex?: IVectorIndex;
+    /**
+     * Optional embedder applied to each record on write, wired together with
+     * {@link IFileTreeMemoryStoreCreateParams.vectorIndex | vectorIndex}. The
+     * consumer supplies it (e.g. `callProviderEmbedding` or in-process
+     * transformers); the store never calls an embedding provider directly, so the
+     * core stays embedder-agnostic. Embedding/index maintenance is **best-effort**:
+     * a failed (or throwing) `embed` / `add` / `remove` is logged at `warn` via
+     * {@link IFileTreeMemoryStoreCreateParams.logger | logger} and the record
+     * operation still succeeds — the vector index is a derived view that a later
+     * `rebuild` reconciles, so a vector failure never fails an authoritative write.
+     */
+    readonly embed?: MemoryEmbedder;
+}
+/**
+ * Flat-layout, FileTree-backed {@link IMemoryStore}. The FileTree is the source
+ * of truth; the {@link IMemoryIndex} is a derived in-memory view patched on
+ * every write. Concurrent writes are serialized through a per-instance async
+ * write-lock so the index and the on-disk files never interleave.
+ *
+ * @remarks
+ * B1 supports flat (non-versioned) layout only and string (markdown) bodies.
+ * A codec reporting `isVersioned: true`, or a non-string body, fails loudly —
+ * the versioned/temporal write path is a fast-follow.
+ * @public
+ */
+export declare class FileTreeMemoryStore implements IMemoryStore {
+    private readonly _root;
+    private readonly _registry;
+    private readonly _writePolicies;
+    private readonly _codecs;
+    private readonly _defaultCodec;
+    private readonly _defaultPolicy;
+    private readonly _scopeEncoding;
+    private readonly _clock;
+    private readonly _index;
+    private readonly _hasher;
+    private readonly _observers;
+    private readonly _logger;
+    private readonly _vectorIndex;
+    private readonly _embed;
+    /** Monotonic write counter; incremented inside the write-lock on each put. */
+    private _seq;
+    /**
+     * Monotonic observation-sequence counter. A distinct authority from `_seq`
+     * (the envelope write counter): it numbers the audit stream so a single
+     * {@link MemoryObservationStore} fed by this store sees strictly increasing
+     * `seq`, satisfying the ring buffer's cursor contract.
+     */
+    private _observationSeq;
+    /** Tail of the write-lock promise chain that serializes mutating ops. */
+    private _writeTail;
+    /**
+     * The record-level mutable-field vocabulary: maps a declared mutable field
+     * name to its canonical location on a record. Used to project an incoming
+     * record into a merge-patch on update. B1 ships the knowledge-LWW surface
+     * (body + envelope metadata); body-internal mutable fields (Phase-C cap-cull)
+     * extend this map.
+     */
+    private static readonly _mutableFieldAccessors;
+    private constructor();
+    /**
+     * Family-convention factory. Builds the derived index and a default LWW
+     * policy, then performs an initial FileTree walk so an existing vault is
+     * indexed (and the `seq` counter resumes past the highest persisted `seq`).
+     */
+    static create(params: IFileTreeMemoryStoreCreateParams): Result<FileTreeMemoryStore>;
+    /** {@inheritDoc IMemoryStore.get} */
+    get(kind: Kind, entityId: EntityId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    /** {@inheritDoc IMemoryStore.getById} */
+    getById(scope: MemoryScopeKey, id: MemoryId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    /** {@inheritDoc IMemoryStore.list} */
+    list(filter?: IMemoryStoreListFilter): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    /** {@inheritDoc IMemoryStore.put} */
+    put(record: IMemoryRecord<unknown>): Promise<Result<IMemoryRecord<unknown>>>;
+    /** {@inheritDoc IMemoryStore.delete} */
+    delete(kind: Kind, entityId: EntityId): Promise<Result<MemoryId>>;
+    /**
+     * Serialize a mutating task behind the write-lock. Tasks run in submission
+     * order; a failed task does not break the chain for subsequent ones.
+     */
+    private _enqueue;
+    /**
+     * Build and fan out one observation record for a completed op. A no-op when no
+     * observers are wired (the additive-default path pays nothing). The store is
+     * the seq authority — it mints `seq` / `timestamp` so every observer sees the
+     * same record. The scope is resolved best-effort via the codec.
+     */
+    private _fireObservation;
+    /** Invoke one observer, swallowing any failure or throw (logged at `warn`). */
+    private _safeObserve;
+    /**
+     * Log a swallowed-issue warning (observer failure or best-effort vector
+     * maintenance), tolerating a logger that itself throws — diagnostic logging
+     * must never make a store op reject.
+     */
+    private _warnSwallowed;
+    /** Resolve a scope for an observation, best-effort (undefined when unresolvable). */
+    private _scopeBestEffort;
+    private _putLocked;
+    /**
+     * Run dedup → policy → stamp → embed → write for a resolved address and content
+     * hash. Async because the embed-on-write hook (when wired) does a network call
+     * or in-process inference; the whole chain runs inside the write-lock so the
+     * vector index, the on-disk file, and the derived index never interleave.
+     */
+    private _writeResolved;
+    /**
+     * Build → embed → persist → evict for an admitted write.
+     *
+     * The durable record store is authoritative; the vector index is a **derived,
+     * rebuildable** view, so vector maintenance is **best-effort** — a failed embed
+     * or `add` is logged and the durable write still succeeds (the index can be
+     * rebuilt via {@link InMemoryCosineIndex.rebuild}). Only genuine record-store
+     * failures (body/codec/policy, persist, file eviction) fail the `put`.
+     *
+     * Ordering: the embed + `add` run immediately before the single `_persist` so
+     * the index-returned `embeddingRef` lands in one durable write (a post-persist
+     * stamp would need a second write whose failure path is effectively untestable).
+     * Build and persist the replacement BEFORE evicting the cull-oldest cohort, so a
+     * later eviction failure never loses data with nothing written in its place.
+     */
+    private _admitWrite;
+    /**
+     * Best-effort embed-on-write. When a vector index AND an embedder are wired,
+     * embeds the built record, `add`s the vector (replace semantics handle a same-id
+     * re-embed — no explicit remove), and stamps the returned `embeddingRef`. A
+     * failure (returned `fail` OR a thrown/rejected hook) is logged and the
+     * unembedded record is returned unchanged — the put still persists, and the
+     * derived index is reconciled by a later `rebuild`. A pass-through no-op when
+     * unwired (byte-identical record).
+     *
+     * Always succeeds (`Result` is the chain's shape, never a vector-induced
+     * failure).
+     */
+    private _embedOnWrite;
+    /**
+     * Evict the records named by a `cull-oldest` decision, best-effort. Runs only
+     * after the authoritative `_persist`, so a failed eviction is logged (never
+     * fatal) and the cap self-corrects on the next admission. Returns the ids that
+     * were actually evicted (so observations / vector pruning cover only those).
+     * `accept` / `reject` decisions evict nothing.
+     */
+    private _applyEvictions;
+    /** Best-effort vector removal for each evicted record (never fails the put). */
+    private _removeEvictedVectors;
+    /**
+     * Run a consumer-supplied vector hook, normalizing a thrown/rejected hook into a
+     * `Failure` and logging any failure at `warn`. Best-effort: the caller proceeds
+     * regardless, since the index is rebuildable.
+     */
+    private _tryVectorOp;
+    /**
+     * Best-effort vector removal. A no-op unless the full vector lifecycle is wired
+     * (both an index AND an embedder), so an unwired store does no vector work and
+     * behaves byte-identically. Failures are logged, never surfaced — a committed
+     * delete/eviction must not fail because a derived index could not be pruned.
+     */
+    private _removeVectorBestEffort;
+    /**
+     * Build the record to persist. On a first write the incoming envelope is the
+     * base (final content equals the incoming content, so the dedup `hash` is
+     * reused). On an update the incoming record's mutable fields are projected into
+     * a merge-patch and the policy's `applyUpdate` merges them over the existing
+     * record (preserving `created`); the persisted body and `contentHash` are then
+     * taken from the policy's actual output, so a body-transforming policy is never
+     * bypassed and the stored hash always matches the stored `{ kind, body, links }`.
+     * The store stamps the transaction-time metadata it owns
+     * (`created` / `updated` / `seq` / `contentHash`).
+     */
+    private _buildRecord;
+    /** Serialize and write a fully-stamped record, then patch the index. */
+    private _persist;
+    private _deleteLocked;
+    /** Evict (physically delete) a single record file by id, patching the index. */
+    private _evict;
+    /** Project the incoming record's mutable fields into a merge-patch. */
+    private _projectMutablePatch;
+    /**
+     * The admission cohort for a write: every indexed record in `scope` of `kind`
+     * except the one at `idStem` (the record being written or updated). This is
+     * the set a per-kind cap (e.g. {@link MemoryCapCullPolicy}) counts against, so
+     * a bounded-ring policy can keep a per-scope/per-kind family within
+     * `maxRecords`. Excluding the target id makes the post-write count uniform
+     * across first-writes and updates.
+     */
+    private _admissionCohort;
+    /** Find a record in `scope` whose `contentHash` equals `hash`, if any. */
+    private _findByContentHash;
+    private _contentHash;
+    private _codecFor;
+    private _policyFor;
+    /**
+     * Read and validate the record at `<scope>/<idStem>.md`, returning `undefined`
+     * when the scope directory or file is absent. Verifies the on-disk id ↔
+     * filename round-trip on every load.
+     */
+    private _readRecord;
+    /** Enforce `envelope.id === filename stem` and the codec round-trip on load. */
+    private _verifyLoaded;
+    /**
+     * Resolve the directory for a scope, returning `undefined` when it does not
+     * exist. Navigation only — does not create. Folds the path segments through
+     * `getChildren` so an absent segment short-circuits to `undefined`.
+     */
+    private _resolveScopeDir;
+    /** Ensure the scope directory exists, creating segments as needed. */
+    private _ensureScopeDir;
+    /** Write (create or overwrite) `<scope>/<idStem>.md` with `raw`. */
+    private _writeFile;
+    /**
+     * Physically delete `<scope>/<idStem>.md`. The scope-missing and file-missing
+     * guards are unreachable through the callers (`delete` / `_evict` both read the
+     * record first, so the directory and file exist) but are kept so a future
+     * direct caller degrades loudly rather than silently.
+     */
+    private _deleteFile;
+    /**
+     * Walk the FileTree once and rebuild the index. Also resumes the `seq`
+     * counter past the highest persisted `seq` so new writes stay monotonic.
+     */
+    private _initialIndex;
+    /** Recursively collect every `.md` record under `dir` (scope = path segments). */
+    private _collectEntries;
+}
+//# sourceMappingURL=fileTreeMemoryStore.d.ts.map

package/lib/packlets/store/fileTreeMemoryStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileTreeMemoryStore.d.ts","sourceRoot":"","sources":["../../../src/packlets/store/fileTreeMemoryStore.ts"],"names":[],"mappings":"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"}