@j0hanz/memdb 1.0.11 → 1.1.1

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

@@ -1,4 +1,4 @@
-import type { Memory, StatementResult } from '../types/index.js';
+import type { Memory, MemoryStats, StatementResult } from '../types.js';
 export declare const getMemory: (hash: string) => Memory | undefined;
 export declare const deleteMemory: (hash: string) => StatementResult;
-//# sourceMappingURL=memory-read.d.ts.map
+export declare const getStats: () => MemoryStats;

package/dist/core/memory-read.js

@@ -1,6 +1,4 @@
-import { db } from './database.js';
-import { mapRowToMemory, toSafeInteger } from './row-mappers.js';
-import { executeGet, executeRun } from './sqlite.js';
+import { db, executeGet, executeRun, mapRowToMemory, toSafeInteger, } from './db.js';
 const stmtGetMemoryByHash = db.prepare('SELECT * FROM memories WHERE hash = ?');
 const stmtDeleteMemoryByHash = db.prepare('DELETE FROM memories WHERE hash = ?');
 export const getMemory = (hash) => {
@@ -11,4 +9,34 @@ export const deleteMemory = (hash) => {
     const result = executeRun(stmtDeleteMemoryByHash, hash);
     return { changes: toSafeInteger(result.changes, 'changes') };
 };
-//# sourceMappingURL=memory-read.js.map
+const stmtMemoryCount = db.prepare('SELECT COUNT(*) as count FROM memories');
+const stmtTagCount = db.prepare('SELECT COUNT(DISTINCT tag) as count FROM tags');
+const stmtDateRange = db.prepare('SELECT MIN(created_at) as oldest, MAX(created_at) as newest FROM memories');
+const toDateString = (value) => {
+    if (value == null)
+        return null;
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    return null;
+};
+const queryCounts = () => {
+    const memoryRow = executeGet(stmtMemoryCount);
+    const tagRow = executeGet(stmtTagCount);
+    if (!memoryRow)
+        throw new Error('Failed to load memory stats');
+    if (!tagRow)
+        throw new Error('Failed to load tag stats');
+    return { memoryRow, tagRow };
+};
+export const getStats = () => {
+    const { memoryRow, tagRow } = queryCounts();
+    const dateRow = executeGet(stmtDateRange);
+    return {
+        memoryCount: toSafeInteger(memoryRow.count, 'memoryCount'),
+        tagCount: toSafeInteger(tagRow.count, 'tagCount'),
+        oldestMemory: toDateString(dateRow?.oldest),
+        newestMemory: toDateString(dateRow?.newest),
+    };
+};

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

@@ -8,4 +8,3 @@ export declare const getRelated: (input: {
     direction?: RelationDirection;
 }) => RelatedMemory[];
 export {};
-//# sourceMappingURL=memory-relations.d.ts.map

package/dist/core/memory-relations.js

@@ -55,4 +55,3 @@ const getRelatedRecursive = (input) => {
     const incoming = queryIncomingRecursive(memoryId, relationType, maxDepth);
     return deduplicateByHash([...outgoing, ...incoming]);
 };
-//# sourceMappingURL=memory-relations.js.map

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

@@ -1,9 +1,10 @@
 import type { SearchResult } from '../types/index.js';
-export declare const searchMemories: (input: {
+interface SearchInput {
     query: string;
-    limit?: number;
-    tags?: readonly string[];
-    minRelevance?: number;
-    offset?: number;
-}) => SearchResult[];
-//# sourceMappingURL=memory-search.d.ts.map
+    limit?: number | undefined;
+    tags?: readonly string[] | undefined;
+    minRelevance?: number | undefined;
+    offset?: number | undefined;
+}
+export declare const searchMemories: (input: SearchInput) => SearchResult[];
+export {};

package/dist/core/memory-search.js

@@ -1,17 +1,23 @@
 import { mapRowToSearchResult } from './row-mappers.js';
 import { buildSearchQuery, executeSearch } from './search.js';
 import { normalizeTags } from './tags.js';
-export const searchMemories = (input) => {
-    const { query, limit = 10, tags = [], minRelevance, offset } = input;
-    const searchInput = {
-        query,
-        limit,
-        tags: normalizeTags(tags, 50),
-        ...(minRelevance !== undefined ? { minRelevance } : {}),
-        ...(offset !== undefined ? { offset } : {}),
+const buildSearchInput = (input) => {
+    const result = {
+        query: input.query,
+        limit: input.limit ?? 10,
+        tags: normalizeTags(input.tags ?? [], 50),
     };
+    if (input.minRelevance !== undefined) {
+        result.minRelevance = input.minRelevance;
+    }
+    if (input.offset !== undefined) {
+        result.offset = input.offset;
+    }
+    return result;
+};
+export const searchMemories = (input) => {
+    const searchInput = buildSearchInput(input);
     const { sql, params } = buildSearchQuery(searchInput);
     const rows = executeSearch(sql, params);
     return rows.map((row) => mapRowToSearchResult(row));
 };
-//# sourceMappingURL=memory-search.js.map

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

@@ -1,3 +1,2 @@
 import type { MemoryStats } from '../types/index.js';
 export declare const getStats: () => MemoryStats;
-//# sourceMappingURL=memory-stats.d.ts.map

package/dist/core/memory-stats.js

@@ -49,4 +49,3 @@ export const getStats = () => {
         newestMemory: toDateString(dateRow?.newest),
     };
 };
-//# sourceMappingURL=memory-stats.js.map

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

@@ -8,4 +8,3 @@ interface UpdateMemoryOptions {
 }
 export declare const updateMemory: (hash: string, options: UpdateMemoryOptions) => MemoryUpdateResult;
 export {};
-//# sourceMappingURL=memory-updates.d.ts.map

package/dist/core/memory-updates.js

@@ -68,7 +68,7 @@ const enforceTagLimit = (existingTags, tagsToInsert, maxTags) => {
             continue;
         projectedCount += 1;
         if (projectedCount > maxTags) {
-            throw new Error('Too many tags (max ' + String(maxTags) + ')');
+            throw new Error(`Too many tags (max ${maxTags})`);
         }
         existingTags.add(tag);
     }
@@ -113,4 +113,3 @@ export const updateMemory = (hash, options) => {
         return { updated: true, hash };
     });
 };
-//# sourceMappingURL=memory-updates.js.map

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

@@ -0,0 +1,13 @@
+import type { MemoryInsertResult, MemoryUpdateResult } from '../types.js';
+export declare const normalizeTags: (tags: readonly string[], maxTags: number) => string[];
+export declare const findMemoryIdByHash: (hash: string) => number | undefined;
+export declare const createMemory: (input: {
+    content: string;
+    tags?: readonly string[];
+}) => MemoryInsertResult;
+interface UpdateMemoryOptions {
+    content: string;
+    tags?: readonly string[] | undefined;
+}
+export declare const updateMemory: (hash: string, options: UpdateMemoryOptions) => MemoryUpdateResult;
+export {};

package/dist/core/memory-write.js

@@ -0,0 +1,113 @@
+import crypto from 'node:crypto';
+import { db, executeGet, executeRun, toSafeInteger, withImmediateTransaction, } from './db.js';
+const MAX_TAGS = 100;
+const validateTag = (tag) => {
+    if (tag.length === 0) {
+        throw new Error('Tag must be at least 1 character');
+    }
+    if (tag.length > 50) {
+        throw new Error('Tag exceeds 50 characters');
+    }
+};
+const validateTagCount = (tags, maxTags) => {
+    if (tags.length > maxTags) {
+        throw new Error(`Too many tags (max ${maxTags})`);
+    }
+};
+const dedupeTags = (tags) => {
+    const seen = new Set();
+    for (const tag of tags) {
+        validateTag(tag);
+        seen.add(tag);
+    }
+    return [...seen];
+};
+export const normalizeTags = (tags, maxTags) => {
+    if (tags.length === 0)
+        return [];
+    validateTagCount(tags, maxTags);
+    return dedupeTags(tags);
+};
+const stmtFindMemoryIdByHash = db.prepare('SELECT id FROM memories WHERE hash = ?');
+const buildTagInsert = (memoryId, tags) => {
+    const params = tags.flatMap((tag) => [memoryId, tag]);
+    return { params };
+};
+const tagInsertStatements = [];
+const getInsertTagsStatement = (tagCount) => {
+    const cached = tagInsertStatements[tagCount];
+    if (cached)
+        return cached;
+    const placeholders = Array.from({ length: tagCount }, () => '(?, ?)').join(', ');
+    const stmt = db.prepare(`INSERT OR IGNORE INTO tags (memory_id, tag) VALUES ${placeholders}`);
+    tagInsertStatements[tagCount] = stmt;
+    return stmt;
+};
+export const findMemoryIdByHash = (hash) => {
+    const row = executeGet(stmtFindMemoryIdByHash, hash);
+    if (!row)
+        return undefined;
+    return toSafeInteger(row.id, 'id');
+};
+const insertTags = (memoryId, tags) => {
+    if (tags.length === 0)
+        return;
+    const { params } = buildTagInsert(memoryId, tags);
+    const stmt = getInsertTagsStatement(tags.length);
+    executeRun(stmt, ...params);
+};
+const buildHash = (content) => {
+    // eslint-disable-next-line sonarjs/hashing -- MD5 used for non-security deduplication only.
+    return crypto.createHash('md5').update(content).digest('hex');
+};
+const stmtInsertMemory = db.prepare('INSERT OR IGNORE INTO memories (content, hash) VALUES (?, ?) RETURNING id');
+const requireMemoryId = (id) => {
+    if (id === undefined) {
+        throw new Error('Failed to resolve memory id');
+    }
+    return id;
+};
+const resolveMemoryId = (content, hash) => {
+    const inserted = executeGet(stmtInsertMemory, content, hash);
+    if (inserted) {
+        return { id: toSafeInteger(inserted.id, 'id'), isNew: true };
+    }
+    const id = requireMemoryId(findMemoryIdByHash(hash));
+    return { id, isNew: false };
+};
+export const createMemory = (input) => withImmediateTransaction(() => {
+    const { content, tags = [] } = input;
+    const hash = buildHash(content);
+    const normalizedTags = normalizeTags(tags, MAX_TAGS);
+    const { id, isNew } = resolveMemoryId(content, hash);
+    insertTags(id, normalizedTags);
+    return { id, hash, isNew };
+});
+const stmtDeleteTagsForMemory = db.prepare('DELETE FROM tags WHERE memory_id = ?');
+const stmtUpdateContent = db.prepare('UPDATE memories SET content = ?, hash = ? WHERE id = ?');
+const replaceTags = (memoryId, tags) => {
+    executeRun(stmtDeleteTagsForMemory, memoryId);
+    insertTags(memoryId, normalizeTags(tags, MAX_TAGS));
+};
+export const updateMemory = (hash, options) => {
+    const memoryId = findMemoryIdByHash(hash);
+    if (memoryId === undefined)
+        throw new Error('Memory not found');
+    return withImmediateTransaction(() => {
+        const newHash = buildHash(options.content);
+        // Check if new content would create a duplicate
+        if (newHash !== hash) {
+            const existingId = findMemoryIdByHash(newHash);
+            if (existingId !== undefined) {
+                throw new Error('Content already exists as another memory');
+            }
+        }
+        // Update content and hash
+        executeRun(stmtUpdateContent, options.content, newHash, memoryId);
+        // Update tags if provided, otherwise preserve existing tags
+        if (options.tags !== undefined) {
+            replaceTags(memoryId, options.tags);
+        }
+        return { updated: true, oldHash: hash, newHash };
+    });
+};

package/dist/core/relation-queries.d.ts

@@ -5,4 +5,3 @@ export declare const queryBothDirect: (memoryId: number, relationType?: string)
 export declare const queryOutgoingRecursive: (memoryId: number, relationType: string | undefined, maxDepth: number) => RelatedMemory[];
 export declare const queryIncomingRecursive: (memoryId: number, relationType: string | undefined, maxDepth: number) => RelatedMemory[];
 export declare const deduplicateByHash: (memories: RelatedMemory[]) => RelatedMemory[];
-//# sourceMappingURL=relation-queries.d.ts.map

package/dist/core/relation-queries.js

@@ -123,4 +123,3 @@ export const deduplicateByHash = (memories) => {
         .sort((a, b) => a.depth - b.depth || a.id - b.id)
         .slice(0, 1000);
 };
-//# sourceMappingURL=relation-queries.js.map

package/dist/core/relations.d.ts

@@ -0,0 +1,10 @@
+import type { RelatedMemory, StatementResult } from '../types.js';
+type RelationDirection = 'outgoing' | 'incoming' | 'both';
+export declare const linkMemories: (fromHash: string, toHash: string, relationType: string) => StatementResult;
+export declare const getRelated: (input: {
+    hash: string;
+    relationType?: string;
+    depth?: number;
+    direction?: RelationDirection;
+}) => RelatedMemory[];
+export {};

package/dist/core/relations.js

@@ -0,0 +1,177 @@
+import { db, executeAll, executeRun, mapRowToRelatedMemory, prepareCached, toSafeInteger, } from './db.js';
+import { findMemoryIdByHash } from './memory-write.js';
+const stmtInsertRelation = db.prepare('INSERT OR IGNORE INTO relationships (from_memory_id, to_memory_id, ' +
+    'relation_type) VALUES (?, ?, ?)');
+const directConfig = {
+    outgoing: { joinColumn: 'to_memory_id', whereColumn: 'from_memory_id' },
+    incoming: { joinColumn: 'from_memory_id', whereColumn: 'to_memory_id' },
+};
+const recursiveConfig = {
+    outgoing: {
+        baseColumn: 'from_memory_id',
+        joinColumn: 'from_memory_id',
+        relsJoinColumn: 'to_id',
+        memoryJoinColumn: 'to_id',
+    },
+    incoming: {
+        baseColumn: 'to_memory_id',
+        joinColumn: 'to_memory_id',
+        relsJoinColumn: 'from_id',
+        memoryJoinColumn: 'from_id',
+    },
+};
+const typeFilter = (relationType) => relationType
+    ? { clause: ' AND r.relation_type = ?', params: [relationType] }
+    : { clause: '', params: [] };
+const run = (sql, params) => executeAll(prepareCached(sql), ...params).map((row) => mapRowToRelatedMemory(row));
+const buildDirectSql = (input) => {
+    const config = directConfig[input.direction];
+    const limitClause = input.includeLimit === false ? '' : '\n    LIMIT 1000';
+    return `
+    SELECT m.*, r.relation_type as relation_type, 1 as depth
+    FROM memories m
+    JOIN relationships r ON m.id = r.${config.joinColumn}
+    WHERE r.${config.whereColumn} = ?${input.clause}${limitClause}
+  `;
+};
+const buildRecursiveSql = (input) => {
+    const config = recursiveConfig[input.direction];
+    return `
+    WITH RECURSIVE rels(depth, from_id, to_id, relation_type) AS (
+      SELECT 1, r.from_memory_id, r.to_memory_id, r.relation_type
+      FROM relationships r
+      WHERE r.${config.baseColumn} = ?${input.clause}
+      UNION ALL
+      SELECT rels.depth + 1, r.from_memory_id, r.to_memory_id, r.relation_type
+      FROM relationships r
+      JOIN rels ON r.${config.joinColumn} = rels.${config.relsJoinColumn}
+      WHERE rels.depth < ?${input.clause}
+    )
+    SELECT m.*, rels.relation_type as relation_type, MIN(rels.depth) as depth
+    FROM rels
+    JOIN memories m ON m.id = rels.${config.memoryJoinColumn}
+    GROUP BY m.id, rels.relation_type
+    ORDER BY depth, m.id
+    LIMIT 1000
+  `;
+};
+const buildRecursiveParams = (input) => {
+    if (!input.relationType) {
+        return [input.memoryId, input.maxDepth];
+    }
+    return [input.memoryId, ...input.params, input.maxDepth, ...input.params];
+};
+const queryOutgoingDirect = (memoryId, relationType) => {
+    const { clause, params } = typeFilter(relationType);
+    const sql = buildDirectSql({ direction: 'outgoing', clause });
+    return run(sql, [memoryId, ...params]);
+};
+const queryIncomingDirect = (memoryId, relationType) => {
+    const { clause, params } = typeFilter(relationType);
+    const sql = buildDirectSql({ direction: 'incoming', clause });
+    return run(sql, [memoryId, ...params]);
+};
+const queryBothDirect = (memoryId, relationType) => {
+    const { clause, params } = typeFilter(relationType);
+    const outgoingSql = buildDirectSql({
+        direction: 'outgoing',
+        clause,
+        includeLimit: false,
+    });
+    const incomingSql = buildDirectSql({
+        direction: 'incoming',
+        clause,
+        includeLimit: false,
+    });
+    const sql = `
+    ${outgoingSql}
+    UNION
+    ${incomingSql}
+    LIMIT 1000
+  `;
+    return run(sql, [memoryId, ...params, memoryId, ...params]);
+};
+const queryOutgoingRecursive = (memoryId, relationType, maxDepth) => {
+    const { clause, params } = typeFilter(relationType);
+    const sql = buildRecursiveSql({ direction: 'outgoing', clause });
+    const sqlParams = buildRecursiveParams({
+        memoryId,
+        relationType,
+        maxDepth,
+        params,
+    });
+    return run(sql, sqlParams);
+};
+const queryIncomingRecursive = (memoryId, relationType, maxDepth) => {
+    const { clause, params } = typeFilter(relationType);
+    const sql = buildRecursiveSql({ direction: 'incoming', clause });
+    const sqlParams = buildRecursiveParams({
+        memoryId,
+        relationType,
+        maxDepth,
+        params,
+    });
+    return run(sql, sqlParams);
+};
+const deduplicateByHash = (memories) => {
+    const seen = new Map();
+    for (const mem of memories) {
+        const existing = seen.get(mem.hash);
+        if (!existing || mem.depth < existing.depth) {
+            seen.set(mem.hash, mem);
+        }
+    }
+    return [...seen.values()]
+        .sort((a, b) => a.depth - b.depth || a.id - b.id)
+        .slice(0, 1000);
+};
+const resolveMaxDepth = (depth, direction) => {
+    if (direction === 'both') {
+        return Math.min(depth, 2);
+    }
+    return Math.max(1, depth);
+};
+export const linkMemories = (fromHash, toHash, relationType) => {
+    const fromId = findMemoryIdByHash(fromHash);
+    const toId = findMemoryIdByHash(toHash);
+    if (fromId === undefined || toId === undefined) {
+        throw new Error('One or both memories not found');
+    }
+    const result = executeRun(stmtInsertRelation, fromId, toId, relationType);
+    return { changes: toSafeInteger(result.changes, 'changes') };
+};
+export const getRelated = (input) => {
+    const { hash, relationType, depth = 1, direction = 'outgoing' } = input;
+    const memoryId = findMemoryIdByHash(hash);
+    if (memoryId === undefined)
+        return [];
+    const maxDepth = resolveMaxDepth(depth, direction);
+    if (maxDepth === 1) {
+        return getRelatedDirect(memoryId, relationType, direction);
+    }
+    return getRelatedRecursive({
+        memoryId,
+        relationType,
+        maxDepth,
+        direction,
+    });
+};
+const getRelatedDirect = (memoryId, relationType, direction = 'outgoing') => {
+    if (direction === 'outgoing')
+        return queryOutgoingDirect(memoryId, relationType);
+    if (direction === 'incoming')
+        return queryIncomingDirect(memoryId, relationType);
+    return queryBothDirect(memoryId, relationType);
+};
+const getRelatedRecursive = (input) => {
+    const { memoryId, relationType, maxDepth, direction } = input;
+    if (direction === 'outgoing') {
+        return queryOutgoingRecursive(memoryId, relationType, maxDepth);
+    }
+    if (direction === 'incoming') {
+        return queryIncomingRecursive(memoryId, relationType, maxDepth);
+    }
+    const outgoing = queryOutgoingRecursive(memoryId, relationType, maxDepth);
+    const incoming = queryIncomingRecursive(memoryId, relationType, maxDepth);
+    return deduplicateByHash([...outgoing, ...incoming]);
+};

package/dist/core/row-mappers.d.ts

@@ -4,4 +4,3 @@ export declare const toSafeInteger: (value: unknown, field: string) => number;
 export declare const mapRowToMemory: (row: DbRow) => Memory;
 export declare const mapRowToSearchResult: (row: DbRow) => SearchResult;
 export declare const mapRowToRelatedMemory: (row: DbRow) => RelatedMemory;
-//# sourceMappingURL=row-mappers.d.ts.map

package/dist/core/row-mappers.js

@@ -50,4 +50,3 @@ export const mapRowToRelatedMemory = (row) => ({
     relation_type: toString(row.relation_type, 'relation_type'),
     depth: toSafeInteger(row.depth, 'depth'),
 });
-//# sourceMappingURL=row-mappers.js.map

package/dist/core/search-errors.d.ts

@@ -1,2 +1 @@
 export declare const toSearchError: (err: unknown) => Error | undefined;
-//# sourceMappingURL=search-errors.d.ts.map

package/dist/core/search-errors.js

@@ -28,4 +28,3 @@ export const toSearchError = (err) => {
     }
     return undefined;
 };
-//# sourceMappingURL=search-errors.js.map

package/dist/core/search.d.ts

@@ -1,13 +1,6 @@
-import type { DbRow } from './row-mappers.js';
-export declare const buildSearchQuery: (input: {
+import type { SearchResult } from '../types.js';
+interface SearchInput {
     query: string;
-    limit: number;
-    tags: readonly string[];
-    minRelevance?: number;
-    offset?: number;
-}) => {
-    sql: string;
-    params: (number | string)[];
-};
-export declare const executeSearch: (sql: string, params: (number | string)[]) => DbRow[];
-//# sourceMappingURL=search.d.ts.map
+}
+export declare const searchMemories: (input: SearchInput) => SearchResult[];
+export {};