@j0hanz/memdb 1.2.8 → 1.3.0

package/dist/core/search.js

@@ -1,8 +1,15 @@
-import { db, executeAll, loadTagsForMemoryIds, mapRowToRelationship, mapRowToSearchResult, prepareCached, toSafeInteger, } from './db.js';
+import { executeAll, loadTagsForMemoryIds, mapRowToRelationship, mapRowToSearchResult, prepareCached, toSafeInteger, } from './db.js';
 const MAX_QUERY_TOKENS = 50;
 const DEFAULT_LIMIT = 100;
+const MAX_RECALL_DEPTH = 3;
+const MAX_RECALL_MEMORIES = 50;
 const RECENCY_DECAY_DAYS = 7;
 const RECENCY_WEIGHT = 0.15;
+const throwIfAborted = (signal) => {
+    if (signal && typeof signal.throwIfAborted === 'function') {
+        signal.throwIfAborted();
+    }
+};
 const tokenizeQuery = (query) => {
     const parts = query
         .trim()
@@ -15,21 +22,12 @@ const tokenizeQuery = (query) => {
     }
     return parts;
 };
-const buildFtsQuery = (tokens) => {
-    if (tokens.length === 0)
-        return '""';
-    const escaped = tokens.map((t) => `"${t.replace(/"/g, '""')}"`);
-    return escaped.join(' OR ');
-};
-const buildTagPlaceholders = (count) => {
-    return Array.from({ length: count }, () => '?').join(', ');
-};
+const escapeFtsToken = (token) => `"${token.replace(/"/g, '""')}"`;
+const buildFtsQuery = (tokens) => tokens.length === 0 ? '""' : tokens.map(escapeFtsToken).join(' OR ');
 const buildSearchQuery = (tokens) => {
     const ftsQuery = buildFtsQuery(tokens);
-    const tagPlaceholders = buildTagPlaceholders(tokens.length);
     const relevanceExpr = '1.0 / (1.0 + abs(bm25(memories_fts)))';
     const recencyBoost = `MAX(0.0, (${RECENCY_DECAY_DAYS}.0 - julianday('now') + julianday(created_at)) / ${RECENCY_DECAY_DAYS}.0) * ${RECENCY_WEIGHT}`;
-    // Union of FTS content matches and tag matches, deduplicated
     const sql = `
     WITH content_matches AS (
       SELECT m.*, ${relevanceExpr} as base_relevance, ${recencyBoost} as recency_bonus
@@ -41,7 +39,7 @@ const buildSearchQuery = (tokens) => {
       SELECT DISTINCT m.*, 0.5 as base_relevance, ${recencyBoost} as recency_bonus
       FROM memories m
       JOIN tags t ON m.id = t.memory_id
-      WHERE t.tag IN (${tagPlaceholders})
+      WHERE t.tag IN (SELECT value FROM json_each(?))
     ),
     combined AS (
       SELECT *, (base_relevance + recency_bonus) as relevance FROM content_matches
@@ -55,7 +53,7 @@ const buildSearchQuery = (tokens) => {
     ORDER BY relevance DESC
     LIMIT ?
   `;
-    return { sql, params: [ftsQuery, ...tokens, DEFAULT_LIMIT] };
+    return { sql, params: [ftsQuery, JSON.stringify(tokens), DEFAULT_LIMIT] };
 };
 const INDEX_MISSING_TOKENS = [
     'no such module: fts5',
@@ -68,12 +66,10 @@ const getErrorMessage = (err) => err instanceof Error ? err.message : String(err
 const toSearchError = (err) => {
     const message = getErrorMessage(err);
     if (isSearchIndexMissing(message)) {
-        return new Error('Search index unavailable. Ensure FTS5 is enabled and the index is ' +
-            'initialized.');
+        return new Error('Search index unavailable. Ensure FTS5 is enabled and the index is initialized.');
     }
     if (isSearchQueryInvalid(message)) {
-        return new Error('Invalid search query syntax. Check for unbalanced quotes or special ' +
-            'characters. ' +
+        return new Error('Invalid search query syntax. Check for unbalanced quotes or special characters. ' +
             `Details: ${message}`);
     }
     return undefined;
@@ -87,7 +83,8 @@ const executeSearch = (sql, params) => {
         throw toSearchError(err) ?? err;
     }
 };
-const mapRowsToSearchResultsWithTags = (rows) => {
+const enrichSearchResultsWithTags = (rows, signal) => {
+    throwIfAborted(signal);
     const ids = rows.map((row) => toSafeInteger(row.id, 'id'));
     const tagsById = loadTagsForMemoryIds(ids);
     return rows.map((row) => {
@@ -95,78 +92,87 @@ const mapRowsToSearchResultsWithTags = (rows) => {
         return mapRowToSearchResult(row, tagsById.get(id) ?? []);
     });
 };
-export const searchMemories = (input) => {
+export const searchMemories = (input, signal) => {
+    throwIfAborted(signal);
     const tokens = tokenizeQuery(input.query);
-    if (tokens.length === 0) {
+    if (tokens.length === 0)
         throw new Error('Query cannot be empty');
-    }
     const { sql, params } = buildSearchQuery(tokens);
     const rows = executeSearch(sql, params);
-    return mapRowsToSearchResultsWithTags(rows);
-};
-const MAX_RECALL_DEPTH = 3;
-const MAX_RECALL_MEMORIES = 50;
-const buildRecallQuery = (seedCount, depth) => {
-    const seedPlaceholders = Array.from({ length: seedCount }, () => '?').join(', ');
-    const safeDepth = Math.min(Math.max(0, depth), MAX_RECALL_DEPTH);
-    const sql = `
-    WITH RECURSIVE connected(memory_id, depth) AS (
-      -- Seed memories from search results
-      SELECT id, 0 FROM memories WHERE id IN (${seedPlaceholders})
-      UNION
-      -- Follow relationships (both directions) up to max depth
-      SELECT 
-        CASE 
-          WHEN r.from_memory_id = c.memory_id THEN r.to_memory_id
-          ELSE r.from_memory_id
-        END,
-        c.depth + 1
-      FROM relationships r
-      JOIN connected c ON (r.from_memory_id = c.memory_id OR r.to_memory_id = c.memory_id)
-      WHERE c.depth < ${safeDepth}
-    ),
-    unique_memories AS (
-      SELECT DISTINCT memory_id, MIN(depth) as min_depth
-      FROM connected
-      GROUP BY memory_id
-      ORDER BY min_depth
-      LIMIT ${MAX_RECALL_MEMORIES}
-    )
-    SELECT m.*, 1.0 / (1.0 + um.min_depth) as relevance
+    throwIfAborted(signal);
+    return enrichSearchResultsWithTags(rows, signal);
+};
+const normalizeRecallDepth = (depth) => {
+    const raw = depth ?? 1;
+    if (!Number.isFinite(raw))
+        return 1;
+    const asInt = Math.trunc(raw);
+    return Math.min(Math.max(0, asInt), MAX_RECALL_DEPTH);
+};
+const buildRecallQuery = () => `
+  WITH RECURSIVE connected(memory_id, depth) AS (
+    -- Seed memories from search results
+    SELECT m.id, 0
     FROM memories m
-    JOIN unique_memories um ON m.id = um.memory_id
-    ORDER BY um.min_depth, m.created_at DESC
-  `;
-    return { sql };
-};
-const buildRelationshipsQuery = (memoryCount) => {
-    const placeholders = Array.from({ length: memoryCount }, () => '?').join(', ');
-    const sql = `
-    SELECT r.id, r.relation_type, r.created_at,
-           mf.hash as from_hash, mt.hash as to_hash
+    WHERE m.id IN (SELECT value FROM json_each(?))
+
+    UNION
+
+    -- Follow relationships (both directions) up to max depth
+    SELECT 
+      CASE 
+        WHEN r.from_memory_id = c.memory_id THEN r.to_memory_id
+        ELSE r.from_memory_id
+      END,
+      c.depth + 1
     FROM relationships r
-    JOIN memories mf ON r.from_memory_id = mf.id
-    JOIN memories mt ON r.to_memory_id = mt.id
-    WHERE r.from_memory_id IN (${placeholders})
-      AND r.to_memory_id IN (${placeholders})
-    ORDER BY r.relation_type, mf.hash, mt.hash, r.created_at, r.id
-  `;
-    return { sql };
-};
+    JOIN connected c ON (r.from_memory_id = c.memory_id OR r.to_memory_id = c.memory_id)
+    WHERE c.depth < ?
+  ),
+  unique_memories AS (
+    SELECT DISTINCT memory_id, MIN(depth) as min_depth
+    FROM connected
+    GROUP BY memory_id
+    ORDER BY min_depth
+    LIMIT ?
+  )
+  SELECT m.*, 1.0 / (1.0 + um.min_depth) as relevance
+  FROM memories m
+  JOIN unique_memories um ON m.id = um.memory_id
+  ORDER BY um.min_depth, m.created_at DESC
+`;
+const buildRelationshipsQuery = () => `
+  WITH ids(id) AS (SELECT value FROM json_each(?))
+  SELECT r.id, r.relation_type, r.created_at,
+         mf.hash as from_hash, mt.hash as to_hash
+  FROM relationships r
+  JOIN ids a ON r.from_memory_id = a.id
+  JOIN ids b ON r.to_memory_id = b.id
+  JOIN memories mf ON r.from_memory_id = mf.id
+  JOIN memories mt ON r.to_memory_id = mt.id
+  ORDER BY r.relation_type, mf.hash, mt.hash, r.created_at, r.id
+`;
 const executeWithSql = (sql, params) => {
-    const stmt = db.prepare(sql);
+    const stmt = prepareCached(sql);
     return executeAll(stmt, ...params);
 };
 const executeRecall = (seedIds, depth) => {
-    const { sql } = buildRecallQuery(seedIds.length, depth);
-    return executeWithSql(sql, seedIds);
+    if (seedIds.length === 0)
+        return [];
+    const sql = buildRecallQuery();
+    return executeWithSql(sql, [
+        JSON.stringify(seedIds),
+        depth,
+        MAX_RECALL_MEMORIES,
+    ]);
 };
 const loadRelationshipsForMemoryIds = (memoryIds) => {
-    const { sql } = buildRelationshipsQuery(memoryIds.length);
-    const rows = executeWithSql(sql, [...memoryIds, ...memoryIds]);
+    if (memoryIds.length === 0)
+        return [];
+    const sql = buildRelationshipsQuery();
+    const rows = executeWithSql(sql, [JSON.stringify(memoryIds)]);
     return rows.map(mapRowToRelationship);
 };
-const getRecallDepth = (depth) => depth ?? 1;
 const emptyRecallResult = (depth) => ({
     memories: [],
     relationships: [],
@@ -177,26 +183,27 @@ const recallAtDepthZero = (searchResults, depth) => {
         return undefined;
     return { memories: searchResults, relationships: [], depth };
 };
-const recallAtPositiveDepth = (searchResults, depth) => {
+const recallAtPositiveDepth = (searchResults, depth, signal) => {
+    throwIfAborted(signal);
     const seedIds = searchResults.map((m) => m.id);
     const recallRows = executeRecall(seedIds, depth);
-    const memories = mapRowsToSearchResultsWithTags(recallRows);
-    if (memories.length === 0) {
+    throwIfAborted(signal);
+    const memories = enrichSearchResultsWithTags(recallRows, signal);
+    if (memories.length === 0)
         return emptyRecallResult(depth);
-    }
+    throwIfAborted(signal);
     const relationships = loadRelationshipsForMemoryIds(memories.map((m) => m.id));
     return { memories, relationships, depth };
 };
-export const recallMemories = (input) => {
-    const searchResults = searchMemories({ query: input.query });
+export const recallMemories = (input, signal) => {
+    throwIfAborted(signal);
+    const depth = normalizeRecallDepth(input.depth);
+    const searchResults = searchMemories({ query: input.query }, signal);
     if (searchResults.length === 0) {
-        return emptyRecallResult(getRecallDepth(input.depth));
+        return emptyRecallResult(depth);
     }
-    const depth = getRecallDepth(input.depth);
     const depthZeroResult = recallAtDepthZero(searchResults, depth);
-    if (depthZeroResult) {
+    if (depthZeroResult)
         return depthZeroResult;
-    }
-    return recallAtPositiveDepth(searchResults, depth);
+    return recallAtPositiveDepth(searchResults, depth, signal);
 };
-//# sourceMappingURL=search.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,23 +1,18 @@
 #!/usr/bin/env node
+import { readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import process from 'node:process';
 import { McpServer, ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { SUPPORTED_PROTOCOL_VERSIONS } from '@modelcontextprotocol/sdk/types.js';
-import { closeDb } from './core/db.js';
+import pkg from '../package.json' with { type: 'json' };
+import { closeDb, initDb } from './core/db.js';
 import { attachProtocolLogger, logger } from './logger.js';
 import { ProtocolVersionGuardTransport } from './protocol-version-guard.js';
 import { BatchRejectingStdioServerTransport } from './stdio-transport.js';
 import { registerAllTools } from './tools.js';
-const readPackageVersion = async () => {
-    const packageJsonText = await readFile(new URL('../package.json', import.meta.url), {
-        encoding: 'utf-8',
-        signal: AbortSignal.timeout(5000),
-    });
-    const parsed = JSON.parse(packageJsonText);
-    if (typeof parsed !== 'object' || parsed === null)
-        return undefined;
-    const { version } = parsed;
-    return typeof version === 'string' ? version : undefined;
+const readPackageVersion = () => {
+    const { version } = pkg;
+    return Promise.resolve(typeof version === 'string' ? version : undefined);
 };
 const toNonEmptyTrimmedOrUndefined = (text) => {
     const trimmed = text.trim();
@@ -51,14 +46,46 @@ const loadServerMetadata = async () => {
     };
 };
 const { packageVersion, instructions: serverInstructions } = await loadServerMetadata();
+const getLocalIconData = () => {
+    const candidates = ['../assets/logo.svg', './assets/logo.svg'];
+    for (const path of candidates) {
+        try {
+            const url = new URL(path, import.meta.url);
+            const content = readFileSync(url, { encoding: 'base64' });
+            return `data:image/svg+xml;base64,${content}`;
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+};
+const localIcon = getLocalIconData();
 const server = new McpServer({ name: 'memdb', version: packageVersion ?? '0.0.0' }, {
     instructions: serverInstructions,
-    capabilities: { tools: {}, logging: {}, resources: {} },
+    capabilities: { tools: { listChanged: true }, logging: {}, resources: {} },
+    ...(localIcon
+        ? {
+            icons: [
+                { src: localIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
+            ],
+        }
+        : {}),
 });
 const instructionsResource = new ResourceTemplate('internal://instructions', {
     list: undefined,
 });
-server.registerResource('internal://instructions', instructionsResource, { title: 'Instructions', mimeType: 'text/markdown' }, async (uri) => {
+server.registerResource('internal://instructions', instructionsResource, {
+    title: 'Instructions',
+    mimeType: 'text/markdown',
+    ...(localIcon
+        ? {
+            icons: [
+                { src: localIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
+            ],
+        }
+        : {}),
+}, async (uri) => {
     const text = (await readTextFileOrUndefined(new URL('./instructions.md', import.meta.url))) ?? serverInstructions;
     return {
         contents: [
@@ -70,7 +97,7 @@ server.registerResource('internal://instructions', instructionsResource, { title
         ],
     };
 });
-registerAllTools(server);
+registerAllTools(server, localIcon);
 let transport;
 let shuttingDown = false;
 const SHUTDOWN_TIMEOUT = 5000;
@@ -137,6 +164,7 @@ const connectServer = async (transportToUse) => {
 };
 const main = async () => {
     try {
+        await initDb();
         const guardedTransport = createTransport();
         await connectServer(guardedTransport);
     }
@@ -166,4 +194,3 @@ const registerProcessHandlers = () => {
 void main();
 registerSignalHandlers();
 registerProcessHandlers();
-//# sourceMappingURL=index.js.map

package/dist/instructions.md

@@ -1,42 +1,59 @@
 # memdb Instructions
 
-> **Guidance for the Agent:** These instructions are available as a resource (`internal://instructions`). Load them when you are confused about tool usage.
+> Guidance for the Agent: These instructions are available as a resource (`internal://instructions`) or prompt (`get-help`). Load them when you are unsure about tool usage.
 
 ## 1. Core Capability
 
-- **Domain:** Local, SQLite-backed memory store for text notes with tags and relationships.
+- **Domain:** Local SQLite-backed memory store with vector-like text search and graph relationships.
 - **Primary Resources:** `Memory`, `Relationship`, `Stats`.
 
 ## 2. The "Golden Path" Workflows (Critical)
 
-_Describe the standard order of operations. Do not assume the agent knows this._
+_Describe the standard order of operations using ONLY tools that exist._
 
-### Workflow A: Find relevant context
+### Workflow A: Recall & Exploration
 
-1. Call `search_memories` with a focused query.
-2. Call `recall` with `depth: 1`–`2` if you need connected graph context.
-3. Call `get_memory` using the `hash` from results.
-   > **Constraint:** Never guess hashes. Always search or recall first.
+1. Call `search_memories` to find entry points by content/tags.
+2. Call `recall` (depth 1–2) to traverse the knowledge graph from relevant hits.
+3. Call `get_memory` using the `hash` (SHA-256) for exact retrieval.
+   > Constraint: Never guess hashes. Always search or recall first.
 
-### Workflow B: Store or revise knowledge
+### Workflow B: Knowledge Management
 
-1. Call `store_memory` (single) or `store_memories` (batch).
-2. Use `update_memory` to revise; the response returns `{ newHash }`.
-3. Call `create_relationship` to link memories when needed.
-4. Call `delete_memory` / `delete_memories` / `delete_relationship` only with explicit user intent.
+1. Call `store_memory` (single) or `store_memories` (batch) to add context.
+2. Call `create_relationship` to link related memories (directed).
+3. Call `update_memory` to revise; this changes the hash.
+4. Call `delete_memory` only with user confirmation.
 
-## 3. Tool Nuances & "Gotchas"
+## 3. Tool Nuances & Gotchas
 
-- **`search_memories`**: Query is 1–1000 chars and max 50 terms; whitespace-only is invalid.
-- **`recall`**: `depth` is 0–3; depth 0 returns no relationships.
-- **`update_memory`**: Content changes produce a new hash; the tool returns `{ newHash: string }`.
-- **`delete_*` tools**: Destructive—confirm user intent before calling.
-- **Tags**: 1–100 tags, no whitespace, max 50 chars; prefer `kebab-case`.
-- **Hashes**: 32 hex chars; case-insensitive but normalized to lowercase.
+_Do NOT repeat JSON schema. Focus on behavior and pitfalls._
+
+- **`search_memories`**
+  - **Purpose:** Full-text search over content and tags.
+  - **Inputs:** `query` string (required).
+  - **Common failure modes:** Empty results for too-specific queries; try broader terms.
+
+- **`recall`**
+  - **Purpose:** Graph traversal starting from a defined query.
+  - **Inputs:** `query` string; `depth` (default 1, max 3 recommended).
+  - **Latency:** Higher depth increases time/token usage significantly.
+
+- **`store_memory` / `store_memories`**
+  - **Purpose:** Persist new information.
+  - **Inputs:** `content` (text), `tags` (array of strings).
+  - **Side effects:** Writes to DB. Idempotent if content/tags identical (same hash).
+
+- **`update_memory`**
+  - **Inputs:** `hash` (must exist), new `content`/`tags`.
+  - **Side effects:** Creating a new memory hash; effectively a "move" + "create".
+
+- **`create_relationship`**
+  - **Inputs:** `from_hash`, `to_hash`, `relation_type` (e.g., "related_to").
+  - **Constraint:** Both hashes must exist.
 
 ## 4. Error Handling Strategy
 
-- If you receive `E_NOT_FOUND`, re-run `search_memories` or `get_relationships` to confirm the `hash`.
-- If `E_INVALID_ARG`, check tag formatting, term limits, or batch size (max 50).
-- If `E_TOOL_ERROR` (e.g., FTS issues), call `memory_stats` and retry later.
-- If `E_TIMEOUT`, reduce batch size or split the request.
+- **`E_NOT_FOUND`**: The hash doesn't exist. Re-run search/recall.
+- **`E_TIMEOUT`**: Operation took too long (>5s default). Reduce batch size or depth.
+- **`E_INVALID_ARG`**: Check inputs against schema (e.g. valid hashes).

package/dist/logger.d.ts

@@ -7,4 +7,3 @@ export declare const logger: {
     error: (msg: string, ...args: unknown[]) => void;
 };
 export {};
-//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -33,4 +33,3 @@ export const logger = {
     warn: createWriter('warn'),
     error: createWriter('error'),
 };
-//# sourceMappingURL=logger.js.map

package/dist/protocol-version-guard.d.ts

@@ -18,4 +18,3 @@ export declare class ProtocolVersionGuardTransport implements Transport {
     private handleInitializedNotification;
     private handleBeforeReady;
 }
-//# sourceMappingURL=protocol-version-guard.d.ts.map

package/dist/protocol-version-guard.js

@@ -134,4 +134,3 @@ export class ProtocolVersionGuardTransport {
         }
     }
 }
-//# sourceMappingURL=protocol-version-guard.js.map

package/dist/schemas.d.ts

@@ -79,4 +79,3 @@ export declare const DefaultOutputSchema: z.ZodObject<{
         message: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { MEMORY_TYPES } from './types.js';
-const hashSchema = z.string().regex(/^[a-f0-9]{32}$/i);
+const hashSchema = z.string().regex(/^[a-f0-9]{64}$/i);
 const tagSchema = z
     .string()
     .min(1)
@@ -51,18 +51,22 @@ export const SearchMemoriesInputSchema = z.strictObject({
     }),
 });
 export const GetMemoryInputSchema = z.strictObject({
-    hash: hashSchema.meta({ description: 'MD5 hash of the memory' }),
+    hash: hashSchema.meta({
+        description: 'Hash of the memory (SHA-256, 64 hex chars)',
+    }),
 });
 export const DeleteMemoryInputSchema = z.strictObject({
-    hash: hashSchema.meta({ description: 'MD5 hash of the memory' }),
+    hash: hashSchema.meta({
+        description: 'Hash of the memory (SHA-256, 64 hex chars)',
+    }),
 });
 export const DeleteMemoriesInputSchema = z.strictObject({
     hashes: z.array(hashSchema).min(1).max(50).meta({
-        description: 'MD5 hashes of memories to delete (1-50 hashes)',
+        description: 'Hashes of memories to delete (1-50 hashes)',
     }),
 });
 export const UpdateMemoryInputSchema = z.strictObject({
-    hash: hashSchema.meta({ description: 'MD5 hash of the memory to update' }),
+    hash: hashSchema.meta({ description: 'Hash of the memory to update' }),
     content: contentSchema.meta({ description: 'New content for the memory' }),
     tags: tagsSchema
         .max(100)
@@ -74,10 +78,10 @@ export const MemoryStatsInputSchema = z
     .meta({ description: 'No parameters required' });
 export const CreateRelationshipInputSchema = z.strictObject({
     from_hash: hashSchema.meta({
-        description: 'MD5 hash of the source memory',
+        description: 'SHA-256 hash of the source memory',
     }),
     to_hash: hashSchema.meta({
-        description: 'MD5 hash of the target memory',
+        description: 'SHA-256 hash of the target memory',
     }),
     relation_type: relationTypeSchema.meta({
         description: 'Type of relationship (e.g., "related_to", "causes", "depends_on", "part_of", "follows")',
@@ -85,7 +89,7 @@ export const CreateRelationshipInputSchema = z.strictObject({
 });
 export const GetRelationshipsInputSchema = z.strictObject({
     hash: hashSchema.meta({
-        description: 'MD5 hash of the memory to get relationships for',
+        description: 'SHA-256 hash of the memory to get relationships for',
     }),
     direction: z.enum(['outgoing', 'incoming', 'both']).optional().meta({
         description: 'Direction: outgoing (from this memory), incoming (to this memory), both (default)',
@@ -93,10 +97,10 @@ export const GetRelationshipsInputSchema = z.strictObject({
 });
 export const DeleteRelationshipInputSchema = z.strictObject({
     from_hash: hashSchema.meta({
-        description: 'MD5 hash of the source memory',
+        description: 'SHA-256 hash of the source memory',
     }),
     to_hash: hashSchema.meta({
-        description: 'MD5 hash of the target memory',
+        description: 'SHA-256 hash of the target memory',
     }),
     relation_type: relationTypeSchema.meta({
         description: 'Type of relationship to delete',
@@ -137,4 +141,3 @@ export const DefaultOutputSchema = DefaultOutputSchemaBase.superRefine((value, c
         addIssue(ctx, ['error'], 'error is required when ok is false');
     }
 });
-//# sourceMappingURL=schemas.js.map

package/dist/stdio-transport.d.ts

@@ -30,4 +30,3 @@ export declare class BatchRejectingStdioServerTransport implements Transport {
     private handleReadBufferError;
     private processReadBuffer;
 }
-//# sourceMappingURL=stdio-transport.d.ts.map

package/dist/stdio-transport.js

@@ -258,4 +258,3 @@ export class BatchRejectingStdioServerTransport {
         }
     }
 }
-//# sourceMappingURL=stdio-transport.js.map

package/dist/tools.d.ts

@@ -19,6 +19,5 @@ export interface ToolDependencies {
     deleteRelationship: Dependency<typeof deleteRelationship>;
     recallMemories: Dependency<typeof recallMemories>;
 }
-export declare function registerAllTools(server: McpServer, deps?: ToolDependencies): void;
+export declare function registerAllTools(server: McpServer, localIcon?: string, deps?: ToolDependencies): void;
 export {};
-//# sourceMappingURL=tools.d.ts.map