@j0hanz/memdb 1.2.9 → 1.4.0

package/dist/assets/logo.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="#FFFFFF"
+    stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M3 7c0-1.7 2.7-3 6-3s6 1.3 6 3-2.7 3-6 3-6-1.3-6-3Z" />
+    <path d="M3 7v10c0 1.7 2.7 3 6 3s6-1.3 6-3V7" />
+    <path d="M3 12c0 1.7 2.7 3 6 3s6-1.3 6-3" />
+    <line x1="15" y1="12" x2="16" y2="12" />
+    <rect x="16" y="9" width="6" height="6" rx="1" />
+    <line x1="17.5" y1="9" x2="17.5" y2="8" />
+    <line x1="20.5" y1="9" x2="20.5" y2="8" />
+    <line x1="17.5" y1="15" x2="17.5" y2="16" />
+    <line x1="20.5" y1="15" x2="20.5" y2="16" />
+</svg>

package/dist/async-context.d.ts

@@ -0,0 +1,6 @@
+export interface ToolContextStore {
+    toolName: string;
+    startTime: number;
+}
+export declare const runWithToolContext: <T>(store: ToolContextStore, fn: () => T) => T;
+export declare const getToolContext: () => ToolContextStore | undefined;

package/dist/async-context.js

@@ -0,0 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const toolContextStorage = new AsyncLocalStorage();
+export const runWithToolContext = (store, fn) => toolContextStorage.run(store, fn);
+export const getToolContext = () => toolContextStorage.getStore();

package/dist/config.d.ts

@@ -5,4 +5,3 @@ export declare const config: {
     toolTimeoutMs: number;
 };
 export {};
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import process from 'node:process';
-const DEFAULT_DB_PATH = path.join(process.cwd(), '.memdb', 'memory.db');
+const DEFAULT_DB_PATH = path.resolve('.memdb', 'memory.db');
 const DEFAULT_LOG_LEVEL = 'info';
 const DEFAULT_TOOL_TIMEOUT_MS = 15000;
 const hasNullByte = (value) => value.includes('\0');
@@ -37,10 +37,16 @@ const resolveDbPath = (env) => {
         if (hasNullByte(envPath)) {
             throw new Error('Invalid MEMDB_PATH: null byte detected');
         }
-        if (envPath === ':memory:')
+        const normalizedEnvPath = envPath.trim();
+        if (normalizedEnvPath === ':memory:')
             return ':memory:';
-        if (envPath.length > 0)
-            return path.resolve(envPath);
+        if (normalizedEnvPath.length > 0) {
+            if (process.platform !== 'win32' &&
+                path.win32.isAbsolute(normalizedEnvPath)) {
+                return path.win32.normalize(normalizedEnvPath);
+            }
+            return path.resolve(normalizedEnvPath);
+        }
     }
     return path.resolve(DEFAULT_DB_PATH);
 };
@@ -49,4 +55,3 @@ export const config = {
     logLevel: parseLogLevel(process.env.MEMDB_LOG_LEVEL) ?? DEFAULT_LOG_LEVEL,
     toolTimeoutMs: parseTimeoutMs(process.env.MEMDB_TOOL_TIMEOUT_MS, 'MEMDB_TOOL_TIMEOUT_MS') ?? DEFAULT_TOOL_TIMEOUT_MS,
 };
-//# sourceMappingURL=config.js.map

package/dist/core/abort.d.ts

@@ -0,0 +1 @@
+export declare const throwIfAborted: (signal?: AbortSignal) => void;

package/dist/core/abort.js

@@ -0,0 +1,3 @@
+export const throwIfAborted = (signal) => {
+    signal?.throwIfAborted();
+};

package/dist/core/db.d.ts

@@ -1,20 +1,24 @@
 import { DatabaseSync, type StatementSync } from 'node:sqlite';
 import { type Memory, type Relationship, type SearchResult } from '../types.js';
 export type DbRow = Record<string, unknown>;
+type SqlParam = string | number | bigint | null | Uint8Array;
 export declare const initDb: () => Promise<void>;
 export declare const getDb: () => DatabaseSync;
 export declare const closeDb: () => void;
-export type SqlParam = string | number | bigint | null | Uint8Array;
 export declare const prepareCached: (sql: string) => StatementSync;
-export declare const executeAll: <T = DbRow>(stmt: StatementSync, ...params: SqlParam[]) => T[];
-export declare const executeGet: <T = DbRow>(stmt: StatementSync, ...params: SqlParam[]) => T | undefined;
-export declare const executeRun: (stmt: StatementSync, ...params: SqlParam[]) => {
+export declare const executeAll: (stmt: StatementSync, ...params: SqlParam[]) => DbRow[];
+export declare const sqlAll: (strings: TemplateStringsArray, ...params: SqlParam[]) => DbRow[];
+export declare const sqlGet: (strings: TemplateStringsArray, ...params: SqlParam[]) => DbRow | undefined;
+export declare const sqlRun: (strings: TemplateStringsArray, ...params: SqlParam[]) => {
     changes: number | bigint;
 };
 export declare const withImmediateTransaction: <T>(operation: () => T) => T;
+export declare const withSavepoint: <T>(name: string, operation: () => T) => T;
 export declare const toSafeInteger: (value: unknown, field: string) => number;
 export declare const mapRowToMemory: (row: DbRow, tags?: string[]) => Memory;
 export declare const mapRowToSearchResult: (row: DbRow, tags?: string[]) => SearchResult;
 export declare const mapRowToRelationship: (row: DbRow) => Relationship;
+export declare const findMemoryIdByHash: (hash: string) => number | undefined;
+export declare const requireMemoryIdByHash: (hash: string, message?: string) => number;
 export declare const loadTagsForMemoryIds: (memoryIds: readonly number[]) => Map<number, string[]>;
-//# sourceMappingURL=db.d.ts.map
+export {};

package/dist/core/db.js

@@ -1,3 +1,4 @@
+import assert from 'node:assert/strict';
 import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -66,35 +67,33 @@ const FTS_SYNC_SQL = `
   SELECT id, content, summary FROM memories
   WHERE id NOT IN (SELECT rowid FROM memories_fts);
 `;
-const withTimeout = async (promise, ms, message) => {
+const ensureDbDirectory = async (dbPath) => {
+    if (dbPath === ':memory:')
+        return;
+    const dbDir = path.dirname(dbPath);
+    if (dbDir === '.')
+        return;
+    const timeoutMs = 5000;
     let timeout;
     const timeoutPromise = new Promise((_, reject) => {
         timeout = setTimeout(() => {
-            reject(new Error(message));
-        }, ms);
+            reject(new Error('Database directory creation timed out'));
+        }, timeoutMs);
     });
     try {
-        return await Promise.race([promise, timeoutPromise]);
+        await Promise.race([mkdir(dbDir, { recursive: true }), timeoutPromise]);
     }
     finally {
         if (timeout)
             clearTimeout(timeout);
     }
 };
-const ensureDbDirectory = async (dbPath) => {
-    if (dbPath === ':memory:')
-        return;
-    await withTimeout(mkdir(path.dirname(dbPath), { recursive: true }), 5000, 'Database directory creation timed out');
-};
 const enableDefensiveMode = (database) => {
     const extended = database;
     if (typeof extended.enableDefensive === 'function') {
         extended.enableDefensive(true);
     }
 };
-const isInTransaction = (database) => {
-    return database.isTransaction;
-};
 const initializeSchema = (database) => {
     database.exec(SCHEMA_SQL);
     database.exec(FTS_SYNC_SQL);
@@ -129,71 +128,79 @@ export const getDb = () => {
     }
     return dbInstance;
 };
-export const closeDb = () => {
-    if (dbInstance?.isOpen) {
-        dbInstance.close();
-        dbInstance = undefined;
-        statementCache.clear();
+const MAX_CACHED_STATEMENTS = 200;
+let sqlTagStore;
+const getSqlTagStore = () => {
+    const db = getDb();
+    sqlTagStore ??= db.createTagStore(MAX_CACHED_STATEMENTS);
+    return sqlTagStore;
+};
+const resetSqlTagStore = () => {
+    if (!sqlTagStore)
+        return;
+    if ('reset' in sqlTagStore && typeof sqlTagStore.reset === 'function') {
+        sqlTagStore.reset();
+        return;
+    }
+    if ('clear' in sqlTagStore && typeof sqlTagStore.clear === 'function') {
+        sqlTagStore.clear();
     }
 };
-const MAX_CACHED_STATEMENTS = 200;
-const statementCache = new Map();
+class LruStatementCache {
+    maxSize;
+    cache = new Map();
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    get(sql) {
+        const hit = this.cache.get(sql);
+        if (!hit)
+            return undefined;
+        // Refresh LRU order
+        this.cache.delete(sql);
+        this.cache.set(sql, hit);
+        return hit;
+    }
+    set(sql, stmt) {
+        this.cache.set(sql, stmt);
+        if (this.cache.size <= this.maxSize)
+            return;
+        const oldestKey = this.cache.keys().next().value;
+        if (oldestKey)
+            this.cache.delete(oldestKey);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const statementCache = new LruStatementCache(MAX_CACHED_STATEMENTS);
+export const closeDb = () => {
+    if (!dbInstance?.isOpen)
+        return;
+    dbInstance.close();
+    dbInstance = undefined;
+    resetSqlTagStore();
+    sqlTagStore = undefined;
+    statementCache.clear();
+};
 export const prepareCached = (sql) => {
     const cached = statementCache.get(sql);
-    if (cached) {
-        statementCache.delete(sql);
-        statementCache.set(sql, cached);
+    if (cached)
         return cached;
-    }
     const stmt = getDb().prepare(sql);
     statementCache.set(sql, stmt);
-    if (statementCache.size > MAX_CACHED_STATEMENTS) {
-        const oldestKey = statementCache.keys().next().value;
-        if (oldestKey)
-            statementCache.delete(oldestKey);
-    }
     return stmt;
 };
-const isDbRow = (value) => {
-    return typeof value === 'object' && value !== null;
-};
-const assertDbRow = (value) => {
-    if (!isDbRow(value)) {
-        throw new Error('Invalid row');
-    }
-    return value;
-};
-const toDbRowArray = (value) => {
-    if (!Array.isArray(value)) {
-        throw new Error('Expected rows array');
-    }
-    return value.map(assertDbRow);
-};
-const toDbRowOrUndefined = (value) => {
-    if (value === undefined)
-        return undefined;
-    return assertDbRow(value);
-};
-const toRunResult = (value) => {
-    if (typeof value !== 'object' || value === null) {
-        throw new Error('Invalid run result');
-    }
-    const result = value;
-    const { changes } = result;
-    if (typeof changes !== 'number' && typeof changes !== 'bigint') {
-        throw new Error('Invalid run result');
-    }
-    return { changes };
+export const executeAll = (stmt, ...params) => stmt.all(...params);
+export const sqlAll = (strings, ...params) => getSqlTagStore().all(strings, ...params);
+export const sqlGet = (strings, ...params) => getSqlTagStore().get(strings, ...params);
+export const sqlRun = (strings, ...params) => {
+    const res = getSqlTagStore().run(strings, ...params);
+    return { changes: res.changes };
 };
-export const executeAll = (stmt, ...params) => toDbRowArray(stmt.all(...params));
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
-export const executeGet = (stmt, ...params) => toDbRowOrUndefined(stmt.get(...params));
-export const executeRun = (stmt, ...params) => toRunResult(stmt.run(...params));
 export const withImmediateTransaction = (operation) => {
     const db = getDb();
-    if (isInTransaction(db)) {
-        throw new Error('Cannot start nested transaction');
-    }
+    assert.ok(!db.isTransaction, 'Cannot start nested transaction');
     db.exec('BEGIN IMMEDIATE');
     try {
         const result = operation();
@@ -205,6 +212,22 @@ export const withImmediateTransaction = (operation) => {
         throw err;
     }
 };
+const SAVEPOINT_NAME_PATTERN = /^[A-Za-z_]\w*$/;
+export const withSavepoint = (name, operation) => {
+    assert.ok(SAVEPOINT_NAME_PATTERN.test(name), `Invalid savepoint name: ${name}`);
+    const db = getDb();
+    db.exec(`SAVEPOINT ${name}`);
+    try {
+        const result = operation();
+        db.exec(`RELEASE ${name}`);
+        return result;
+    }
+    catch (err) {
+        db.exec(`ROLLBACK TO ${name}`);
+        db.exec(`RELEASE ${name}`);
+        throw err;
+    }
+};
 const createFieldError = (field) => new Error(`Invalid ${field}`);
 const assertFiniteNumber = (value, field) => {
     if (!Number.isFinite(value)) {
@@ -228,82 +251,135 @@ export const toSafeInteger = (value, field) => {
     }
     return numeric;
 };
-const toString = (value, field) => {
-    if (typeof value === 'string')
-        return value;
-    throw createFieldError(field);
+export const mapRowToMemory = (row, tags = []) => {
+    const { id: idRaw, content, summary: summaryRaw, importance: impRaw = 0, memory_type: typeRaw = 'general', created_at: created, accessed_at: accessed, hash, } = row;
+    const id = typeof idRaw === 'bigint' ? Number(idRaw) : idRaw;
+    if (!Number.isSafeInteger(id))
+        throw new Error('Invalid id');
+    if (typeof content !== 'string')
+        throw new Error('Invalid content');
+    let summary;
+    if (summaryRaw === null || summaryRaw === undefined) {
+        summary = undefined;
+    }
+    else if (typeof summaryRaw === 'string') {
+        summary = summaryRaw;
+    }
+    else {
+        throw new Error('Invalid summary');
+    }
+    const importance = typeof impRaw === 'bigint' ? Number(impRaw) : impRaw;
+    if (!Number.isSafeInteger(importance))
+        throw new Error('Invalid importance');
+    if (typeof typeRaw !== 'string' ||
+        !MEMORY_TYPES.includes(typeRaw)) {
+        throw new Error('Invalid memory_type');
+    }
+    if (typeof created !== 'string')
+        throw new Error('Invalid created_at');
+    if (typeof accessed !== 'string')
+        throw new Error('Invalid accessed_at');
+    if (typeof hash !== 'string')
+        throw new Error('Invalid hash');
+    return {
+        id,
+        content,
+        summary,
+        tags,
+        importance,
+        memory_type: typeRaw,
+        created_at: created,
+        accessed_at: accessed,
+        hash,
+    };
 };
-const isMemoryType = (value) => MEMORY_TYPES.includes(value);
-const toMemoryType = (value, field) => {
-    const str = toString(value, field);
-    if (!isMemoryType(str)) {
-        throw createFieldError(field);
+export const mapRowToSearchResult = (row, tags = []) => {
+    const memory = mapRowToMemory(row, tags);
+    const relRaw = row.relevance;
+    let relevance = 0;
+    if (relRaw !== null && relRaw !== undefined) {
+        if (typeof relRaw === 'bigint') {
+            relevance = Number(relRaw);
+        }
+        else {
+            relevance = relRaw;
+        }
     }
-    return str;
+    if (!Number.isFinite(relevance))
+        throw new Error('Invalid relevance');
+    return {
+        ...memory,
+        relevance,
+    };
 };
-const toOptionalString = (value, field) => {
-    if (value === null || value === undefined)
-        return undefined;
-    return toString(value, field);
+export const mapRowToRelationship = (row) => {
+    const { id: idRaw, from_hash: fromHash, to_hash: toHash, relation_type: relationType, created_at: created, } = row;
+    const id = typeof idRaw === 'bigint' ? Number(idRaw) : idRaw;
+    if (!Number.isSafeInteger(id))
+        throw new Error('Invalid id');
+    if (typeof fromHash !== 'string')
+        throw new Error('Invalid from_hash');
+    if (typeof toHash !== 'string')
+        throw new Error('Invalid to_hash');
+    if (typeof relationType !== 'string')
+        throw new Error('Invalid relation_type');
+    if (typeof created !== 'string')
+        throw new Error('Invalid created_at');
+    return {
+        id,
+        from_hash: fromHash,
+        to_hash: toHash,
+        relation_type: relationType,
+        created_at: created,
+    };
 };
-const toOptionalNumber = (value, field) => {
-    if (value === null || value === undefined)
+export const findMemoryIdByHash = (hash) => {
+    const row = sqlGet `SELECT id FROM memories WHERE hash = ${hash}`;
+    if (!row)
         return undefined;
-    return toNumber(value, field);
+    const idRaw = row.id;
+    const id = typeof idRaw === 'bigint' ? Number(idRaw) : idRaw;
+    if (!Number.isSafeInteger(id))
+        throw new Error('Invalid id');
+    return id;
 };
-export const mapRowToMemory = (row, tags = []) => ({
-    id: toSafeInteger(row.id, 'id'),
-    content: toString(row.content, 'content'),
-    summary: toOptionalString(row.summary, 'summary'),
-    tags,
-    importance: toSafeInteger(row.importance ?? 0, 'importance'),
-    memory_type: toMemoryType(row.memory_type ?? 'general', 'memory_type'),
-    created_at: toString(row.created_at, 'created_at'),
-    accessed_at: toString(row.accessed_at, 'accessed_at'),
-    hash: toString(row.hash, 'hash'),
-});
-export const mapRowToSearchResult = (row, tags = []) => ({
-    ...mapRowToMemory(row, tags),
-    relevance: toOptionalNumber(row.relevance, 'relevance') ?? 0,
-});
-export const mapRowToRelationship = (row) => ({
-    id: toSafeInteger(row.id, 'id'),
-    from_hash: toString(row.from_hash, 'from_hash'),
-    to_hash: toString(row.to_hash, 'to_hash'),
-    relation_type: toString(row.relation_type, 'relation_type'),
-    created_at: toString(row.created_at, 'created_at'),
-});
-const dedupeIds = (ids) => {
-    const seen = new Set();
-    const unique = [];
-    for (const id of ids) {
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        unique.push(id);
-    }
-    return unique;
-};
-const pushToMapArray = (map, key, value) => {
-    const existing = map.get(key);
-    if (existing) {
-        existing.push(value);
-        return;
-    }
-    map.set(key, [value]);
+export const requireMemoryIdByHash = (hash, message = `Memory not found: ${hash}`) => {
+    const id = findMemoryIdByHash(hash);
+    if (id === undefined)
+        throw new Error(message);
+    return id;
 };
 export const loadTagsForMemoryIds = (memoryIds) => {
-    const uniqueIds = dedupeIds(memoryIds);
+    const uniqueIds = [];
+    const seen = new Set();
+    for (const id of memoryIds) {
+        if (!seen.has(id)) {
+            seen.add(id);
+            uniqueIds.push(id);
+        }
+    }
     if (uniqueIds.length === 0)
         return new Map();
-    const stmtSelectTags = prepareCached('SELECT memory_id, tag FROM tags WHERE memory_id IN (SELECT value FROM json_each(?)) ORDER BY memory_id, tag');
-    const rows = executeAll(stmtSelectTags, JSON.stringify(uniqueIds));
+    const rows = sqlAll `
+    SELECT memory_id, tag
+    FROM tags
+    WHERE memory_id IN (SELECT value FROM json_each(${JSON.stringify(uniqueIds)}))
+    ORDER BY memory_id, tag
+  `;
     const tagsById = new Map();
     for (const row of rows) {
-        const memoryId = toSafeInteger(row.memory_id, 'memory_id');
-        const tag = toString(row.tag, 'tag');
-        pushToMapArray(tagsById, memoryId, tag);
+        const memoryIdRaw = row.memory_id;
+        const memoryId = typeof memoryIdRaw === 'bigint'
+            ? Number(memoryIdRaw)
+            : memoryIdRaw;
+        const tag = row.tag;
+        const list = tagsById.get(memoryId);
+        if (list) {
+            list.push(tag);
+        }
+        else {
+            tagsById.set(memoryId, [tag]);
+        }
     }
     return tagsById;
 };
-//# sourceMappingURL=db.js.map

package/dist/core/memory-read.d.ts

@@ -1,6 +1,5 @@
 import type { BatchDeleteResult, Memory, MemoryStats, StatementResult } from '../types.js';
 export declare const getMemory: (hash: string) => Memory | undefined;
 export declare const deleteMemory: (hash: string) => StatementResult;
-export declare const deleteMemories: (hashes: string[]) => BatchDeleteResult;
+export declare const deleteMemories: (hashes: string[], signal?: AbortSignal) => BatchDeleteResult;
 export declare const getStats: () => MemoryStats;
-//# sourceMappingURL=memory-read.d.ts.map

package/dist/core/memory-read.js

@@ -1,10 +1,9 @@
-import { executeGet, executeRun, loadTagsForMemoryIds, mapRowToMemory, prepareCached, toSafeInteger, withImmediateTransaction, } from './db.js';
+import { throwIfAborted } from './abort.js';
+import { loadTagsForMemoryIds, mapRowToMemory, sqlGet, sqlRun, toSafeInteger, withImmediateTransaction, } from './db.js';
+const loadMemoryRowByHash = (hash) => sqlGet `SELECT * FROM memories WHERE hash = ${hash}`;
 export const getMemory = (hash) => {
     return withImmediateTransaction(() => {
-        const stmtTouchMemoryByHash = prepareCached('UPDATE memories SET accessed_at = CURRENT_TIMESTAMP WHERE hash = ?');
-        executeRun(stmtTouchMemoryByHash, hash);
-        const stmtGetMemoryByHash = prepareCached('SELECT * FROM memories WHERE hash = ?');
-        const row = executeGet(stmtGetMemoryByHash, hash);
+        const row = loadMemoryRowByHash(hash);
         if (!row)
             return undefined;
         const id = toSafeInteger(row.id, 'id');
@@ -13,32 +12,34 @@ export const getMemory = (hash) => {
     });
 };
 export const deleteMemory = (hash) => {
-    const stmtDeleteMemoryByHash = prepareCached('DELETE FROM memories WHERE hash = ?');
-    const result = executeRun(stmtDeleteMemoryByHash, hash);
+    const result = sqlRun `DELETE FROM memories WHERE hash = ${hash}`;
     return { changes: toSafeInteger(result.changes, 'changes') };
 };
 const deleteMemoryForBatch = (hash) => {
     try {
         const result = deleteMemory(hash);
         const deleted = result.changes > 0;
-        return deleted
-            ? { item: { hash, deleted: true }, succeeded: true }
-            : {
+        if (!deleted) {
+            return {
                 item: { hash, deleted: false, error: 'Memory not found' },
                 succeeded: false,
             };
+        }
+        return { item: { hash, deleted: true }, succeeded: true };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : 'Unknown error';
         return { item: { hash, deleted: false, error: message }, succeeded: false };
     }
 };
-export const deleteMemories = (hashes) => {
-    const results = [];
-    let succeeded = 0;
-    let failed = 0;
+export const deleteMemories = (hashes, signal) => {
     return withImmediateTransaction(() => {
+        const results = [];
+        let succeeded = 0;
+        let failed = 0;
+        throwIfAborted(signal);
         for (const hash of hashes) {
+            throwIfAborted(signal);
             const outcome = deleteMemoryForBatch(hash);
             results.push(outcome.item);
             succeeded += outcome.succeeded ? 1 : 0;
@@ -57,10 +58,8 @@ const toDateString = (value) => {
     return null;
 };
 const queryCounts = () => {
-    const stmtMemoryCount = prepareCached('SELECT COUNT(*) as count FROM memories');
-    const memoryRow = executeGet(stmtMemoryCount);
-    const stmtTagCount = prepareCached('SELECT COUNT(DISTINCT tag) as count FROM tags');
-    const tagRow = executeGet(stmtTagCount);
+    const memoryRow = sqlGet `SELECT COUNT(*) as count FROM memories`;
+    const tagRow = sqlGet `SELECT COUNT(DISTINCT tag) as count FROM tags`;
     if (!memoryRow)
         throw new Error('Failed to load memory stats');
     if (!tagRow)
@@ -69,8 +68,7 @@ const queryCounts = () => {
 };
 export const getStats = () => {
     const { memoryRow, tagRow } = queryCounts();
-    const stmtDateRange = prepareCached('SELECT MIN(created_at) as oldest, MAX(created_at) as newest FROM memories');
-    const dateRow = executeGet(stmtDateRange);
+    const dateRow = sqlGet `SELECT MIN(created_at) as oldest, MAX(created_at) as newest FROM memories`;
     return {
         memoryCount: toSafeInteger(memoryRow.count, 'memoryCount'),
         tagCount: toSafeInteger(tagRow.count, 'tagCount'),
@@ -78,4 +76,3 @@ export const getStats = () => {
         newestMemory: toDateString(dateRow?.newest),
     };
 };
-//# sourceMappingURL=memory-read.js.map

package/dist/core/memory-write.d.ts

@@ -10,11 +10,10 @@ export declare const createMemories: (items: {
     tags?: readonly string[];
     importance?: number;
     memory_type?: MemoryType;
-}[]) => BatchStoreResult;
+}[], signal?: AbortSignal) => BatchStoreResult;
 interface UpdateMemoryOptions {
     content: string;
     tags?: readonly string[] | undefined;
 }
 export declare const updateMemory: (hash: string, options: UpdateMemoryOptions) => MemoryUpdateResult;
 export {};
-//# sourceMappingURL=memory-write.d.ts.map