@j0hanz/memdb 1.0.11 → 1.1.1

package/dist/core/search.js

@@ -1,78 +1,91 @@
-import { toSearchError } from './search-errors.js';
-import { executeAll, prepareCached } from './sqlite.js';
+import { executeAll, mapRowToSearchResult, prepareCached, } from './db.js';
 const MAX_QUERY_TOKENS = 50;
+const DEFAULT_LIMIT = 100;
 const tokenizeQuery = (query) => {
     const parts = query
         .trim()
         .split(/\s+/)
         .filter((w) => w.length > 0);
     if (parts.length === 0)
-        return '""';
+        return [];
     if (parts.length > MAX_QUERY_TOKENS) {
-        throw new Error('Query has too many terms (max ' + String(MAX_QUERY_TOKENS) + ')');
-    }
-    const tokens = [];
-    for (const part of parts) {
-        tokens.push(`"${part.replace(/"/g, '""')}"`);
+        throw new Error(`Query has too many terms (max ${MAX_QUERY_TOKENS})`);
     }
-    return tokens.join(' OR ');
+    return parts;
 };
-const buildTagFilter = (tags) => {
-    if (tags.length === 0)
-        return { clause: '', params: [] };
-    const placeholders = tags.map(() => '?').join(', ');
-    return {
-        clause: ` AND m.id IN (SELECT memory_id FROM tags WHERE tag IN (${placeholders}))`,
-        params: [...tags],
-    };
+const buildFtsQuery = (tokens) => {
+    if (tokens.length === 0)
+        return '""';
+    const escaped = tokens.map((t) => `"${t.replace(/"/g, '""')}"`);
+    return escaped.join(' OR ');
 };
-const buildBaseSql = (whereClause) => {
+const buildTagPlaceholders = (count) => {
+    return Array.from({ length: count }, () => '?').join(', ');
+};
+// Search both content (FTS) and tags, deduplicated by memory id
+const buildSearchQuery = (tokens) => {
+    const ftsQuery = buildFtsQuery(tokens);
+    const tagPlaceholders = buildTagPlaceholders(tokens.length);
     const relevanceExpr = '1.0 / (1.0 + abs(bm25(memories_fts)))';
-    return `
-    WITH ranked AS (
+    // Union of FTS content matches and tag matches, deduplicated
+    const sql = `
+    WITH content_matches AS (
       SELECT m.*, ${relevanceExpr} as relevance
       FROM memories m
       JOIN memories_fts ON m.id = memories_fts.rowid
-      WHERE memories_fts MATCH ?${whereClause}
+      WHERE memories_fts MATCH ?
+    ),
+    tag_matches AS (
+      SELECT DISTINCT m.*, 0.5 as relevance
+      FROM memories m
+      JOIN tags t ON m.id = t.memory_id
+      WHERE t.tag IN (${tagPlaceholders})
+    ),
+    combined AS (
+      SELECT * FROM content_matches
+      UNION ALL
+      SELECT * FROM tag_matches
     )
-    SELECT * FROM ranked
+    SELECT id, content, summary, created_at, accessed_at, hash,
+           MAX(relevance) as relevance
+    FROM combined
+    GROUP BY id
+    ORDER BY relevance DESC
+    LIMIT ?
   `;
+    return { sql, params: [ftsQuery, ...tokens, DEFAULT_LIMIT] };
 };
-const appendMinRelevance = (input) => {
-    if (input.minRelevance === undefined)
-        return input;
-    return {
-        sql: `${input.sql} WHERE relevance >= ?`,
-        params: [...input.params, input.minRelevance],
-    };
-};
-const appendPagination = (input) => {
-    const params = [...input.params, input.limit];
-    let sql = `${input.sql} ORDER BY relevance DESC LIMIT ?`;
-    if (input.offset !== undefined && input.offset > 0) {
-        sql += ' OFFSET ?';
-        params.push(input.offset);
+const INDEX_MISSING_TOKENS = [
+    'no such module: fts5',
+    'no such table: memories_fts',
+];
+const QUERY_INVALID_TOKENS = ['fts5', 'syntax error'];
+const isSearchIndexMissing = (message) => INDEX_MISSING_TOKENS.some((token) => message.includes(token));
+const isSearchQueryInvalid = (message) => QUERY_INVALID_TOKENS.some((token) => message.includes(token));
+const getErrorMessage = (err) => err instanceof Error ? err.message : String(err);
+const SEARCH_ERROR_MAP = [
+    {
+        matches: isSearchIndexMissing,
+        build: () => new Error('Search index unavailable. Ensure FTS5 is enabled and the index is ' +
+            'initialized.'),
+    },
+    {
+        matches: isSearchQueryInvalid,
+        build: (message) => new Error('Invalid search query syntax. Check for unbalanced quotes or special ' +
+            'characters. ' +
+            `Details: ${message}`),
+    },
+];
+const toSearchError = (err) => {
+    const message = getErrorMessage(err);
+    for (const mapping of SEARCH_ERROR_MAP) {
+        if (mapping.matches(message)) {
+            return mapping.build(message);
+        }
     }
-    return { sql, params };
-};
-export const buildSearchQuery = (input) => {
-    const sanitizedQuery = tokenizeQuery(input.query);
-    const tagFilter = buildTagFilter(input.tags);
-    const baseSql = buildBaseSql(tagFilter.clause);
-    const baseParams = [sanitizedQuery, ...tagFilter.params];
-    const baseQuery = { sql: baseSql, params: baseParams };
-    const withRelevance = input.minRelevance === undefined
-        ? baseQuery
-        : appendMinRelevance({
-            ...baseQuery,
-            minRelevance: input.minRelevance,
-        });
-    const paginatedQuery = input.offset === undefined
-        ? { ...withRelevance, limit: input.limit }
-        : { ...withRelevance, limit: input.limit, offset: input.offset };
-    return appendPagination(paginatedQuery);
+    return undefined;
 };
-export const executeSearch = (sql, params) => {
+const executeSearch = (sql, params) => {
     try {
         const stmt = prepareCached(sql);
         return executeAll(stmt, ...params);
@@ -85,4 +98,12 @@ export const executeSearch = (sql, params) => {
         throw err;
     }
 };
-//# sourceMappingURL=search.js.map
+export const searchMemories = (input) => {
+    const tokens = tokenizeQuery(input.query);
+    if (tokens.length === 0) {
+        throw new Error('Query cannot be empty');
+    }
+    const { sql, params } = buildSearchQuery(tokens);
+    const rows = executeSearch(sql, params);
+    return rows.map((row) => mapRowToSearchResult(row));
+};

package/dist/core/sqlite.d.ts

@@ -8,4 +8,3 @@ export declare const executeRun: (stmt: StatementSync, ...params: SqlParam[]) =>
     changes: number | bigint;
 };
 export declare const withImmediateTransaction: <T>(operation: () => T) => T;
-//# sourceMappingURL=sqlite.d.ts.map

package/dist/core/sqlite.js

@@ -8,9 +8,7 @@ const enforceStatementCacheLimit = () => {
     const oldestSql = statementCacheOrder.shift();
     if (!oldestSql)
         return;
-    const toEvict = statementCache.get(oldestSql);
     statementCache.delete(oldestSql);
-    void toEvict;
 };
 const isDbRow = (value) => {
     return typeof value === 'object' && value !== null;
@@ -71,4 +69,3 @@ export const withImmediateTransaction = (operation) => {
         throw err;
     }
 };
-//# sourceMappingURL=sqlite.js.map

package/dist/core/tags.d.ts

@@ -1,2 +1 @@
 export declare const normalizeTags: (tags: readonly string[], maxTags: number) => string[];
-//# sourceMappingURL=tags.d.ts.map

package/dist/core/tags.js

@@ -8,7 +8,7 @@ const validateTag = (tag) => {
 };
 const validateTagCount = (tags, maxTags) => {
     if (tags.length > maxTags) {
-        throw new Error('Too many tags (max ' + String(maxTags) + ')');
+        throw new Error(`Too many tags (max ${maxTags})`);
     }
 };
 const dedupeTags = (tags) => {
@@ -25,4 +25,3 @@ export const normalizeTags = (tags, maxTags) => {
     validateTagCount(tags, maxTags);
     return dedupeTags(tags);
 };
-//# sourceMappingURL=tags.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

@@ -3,28 +3,46 @@ import { readFile } from 'node:fs/promises';
 import process from 'node:process';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { closeDb } from './core/database.js';
-import { registerAllTools } from './tools/index.js';
-import { config } from './utils/config.js';
-import { logger } from './utils/logger.js';
-const packageJsonText = await readFile(new URL('../package.json', import.meta.url), {
-    encoding: 'utf-8',
-    signal: AbortSignal.timeout(5000),
-});
-const packageVersion = (() => {
+import { SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
+import { closeDb } from './core/db.js';
+import { logger } from './logger.js';
+import { ProtocolVersionGuardTransport } from './protocol-version-guard.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 = Reflect.get(parsed, 'version');
     return typeof version === 'string' ? version : undefined;
-})();
+};
+const packageVersion = await readPackageVersion();
 const server = new McpServer({ name: 'memdb', version: packageVersion ?? '0.0.0' }, {
     instructions: 'A Memory MCP Server for AI Assistants using node:sqlite',
     capabilities: { logging: {}, tools: {} },
 });
+const patchToolErrorResults = (target) => {
+    const patched = target;
+    patched.createToolError = (message) => {
+        const structured = {
+            ok: false,
+            error: { code: 'E_TOOL_ERROR', message },
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(structured) }],
+            structuredContent: structured,
+            isError: true,
+        };
+    };
+};
+patchToolErrorResults(server);
 registerAllTools(server);
 let transport;
 let shuttingDown = false;
+const SHUTDOWN_TIMEOUT = 5000;
 async function shutdown(signal) {
     if (shuttingDown)
         return;
@@ -33,45 +51,48 @@ async function shutdown(signal) {
     const forceExitTimer = setTimeout(() => {
         logger.warn('Shutdown timeout exceeded, forcing exit');
         process.exit(1);
-    }, config.shutdownTimeout);
-    const exit = (code) => {
-        clearTimeout(forceExitTimer);
-        process.exit(code);
-    };
+    }, SHUTDOWN_TIMEOUT);
     try {
         closeDb();
-        if (transport) {
-            await transport.close();
-        }
-        exit(0);
+        await transport?.close();
+        clearTimeout(forceExitTimer);
+        process.exit(0);
     }
     catch (err) {
         logger.error('Error during shutdown:', err);
-        exit(1);
+        clearTimeout(forceExitTimer);
+        process.exit(1);
     }
 }
-async function main() {
+const main = async () => {
     try {
-        const stdio = new StdioServerTransport();
-        transport = stdio;
-        await server.connect(stdio);
+        const stdioTransport = new StdioServerTransport();
+        const guardedTransport = new ProtocolVersionGuardTransport(stdioTransport, SUPPORTED_PROTOCOL_VERSIONS);
+        transport = guardedTransport;
+        await server.connect(guardedTransport);
         logger.info('Memory MCP Server running on stdio');
     }
     catch (error) {
         logger.error('Failed to start server', error);
         process.exit(1);
     }
-}
+};
+const registerSignalHandlers = () => {
+    const signals = ['SIGTERM', 'SIGINT', 'SIGBREAK'];
+    for (const signal of signals) {
+        process.on(signal, () => void shutdown(signal));
+    }
+};
+const registerProcessHandlers = () => {
+    process.on('uncaughtException', (err, origin) => {
+        logger.error(`Uncaught exception (${origin}):`, err);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        logger.error('Unhandled rejection:', reason);
+        process.exit(1);
+    });
+};
 void main();
-process.on('SIGTERM', () => void shutdown('SIGTERM'));
-process.on('SIGINT', () => void shutdown('SIGINT'));
-process.on('SIGBREAK', () => void shutdown('SIGBREAK'));
-process.on('uncaughtException', (err, origin) => {
-    logger.error(`Uncaught exception (${origin}):`, err);
-    process.exit(1);
-});
-process.on('unhandledRejection', (reason) => {
-    logger.error('Unhandled rejection:', reason);
-    process.exit(1);
-});
-//# sourceMappingURL=index.js.map
+registerSignalHandlers();
+registerProcessHandlers();

package/dist/lib/errors.d.ts

@@ -17,4 +17,3 @@ type ErrorResponse = CallToolResult & {
 export declare function getErrorMessage(error: unknown): string;
 export declare function createErrorResponse(code: string, message: string, result?: unknown): ErrorResponse;
 export {};
-//# sourceMappingURL=errors.d.ts.map

package/dist/lib/errors.js

@@ -20,4 +20,3 @@ export function createErrorResponse(code, message, result) {
         isError: true,
     };
 }
-//# sourceMappingURL=errors.js.map

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: {
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+};

package/dist/logger.js

@@ -0,0 +1,17 @@
+import { config } from './config.js';
+const LEVELS = {
+    error: 0,
+    warn: 1,
+    info: 2,
+};
+const threshold = LEVELS[config.logLevel];
+const createWriter = (level) => (msg, ...args) => {
+    if (LEVELS[level] > threshold)
+        return;
+    console.error(`[${level.toUpperCase()}] ${msg}`, ...args);
+};
+export const logger = {
+    info: createWriter('info'),
+    warn: createWriter('warn'),
+    error: createWriter('error'),
+};

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

@@ -0,0 +1,17 @@
+import type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { type JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export declare class ProtocolVersionGuardTransport implements Transport {
+    readonly inner: Transport;
+    private readonly supportedVersions;
+    onclose: () => void;
+    onerror: (error: Error) => void;
+    onmessage: NonNullable<Transport['onmessage']>;
+    private sawInitialize;
+    private ready;
+    constructor(inner: Transport, supportedVersions: readonly string[]);
+    setProtocolVersion(version: string): void;
+    start(): Promise<void>;
+    send(message: JSONRPCMessage, options?: TransportSendOptions): Promise<void>;
+    close(): Promise<void>;
+    private handleMessage;
+}

package/dist/protocol-version-guard.js

@@ -0,0 +1,100 @@
+import { isInitializedNotification, isInitializeRequest, isJSONRPCErrorResponse, isJSONRPCRequest, isJSONRPCResultResponse, } from '@modelcontextprotocol/sdk/types.js';
+const buildUnsupportedVersionMessage = (version, supportedVersions) => `Unsupported protocol version: ${version} (supported versions: ${supportedVersions.join(', ')})`;
+const isObject = (value) => typeof value === 'object' && value !== null;
+const getInitializeInfo = (message) => {
+    if (!isInitializeRequest(message))
+        return undefined;
+    const { params, id } = message;
+    if (typeof id !== 'string' && typeof id !== 'number')
+        return undefined;
+    if (!isObject(params))
+        return undefined;
+    const { protocolVersion } = params;
+    if (typeof protocolVersion !== 'string')
+        return undefined;
+    return { id, protocolVersion };
+};
+const createUnsupportedVersionError = (id, version, supportedVersions) => ({
+    jsonrpc: '2.0',
+    id,
+    error: {
+        code: -32000,
+        message: buildUnsupportedVersionMessage(version, supportedVersions),
+    },
+});
+const createLifecycleError = (id, message) => ({
+    jsonrpc: '2.0',
+    id,
+    error: {
+        code: -32600,
+        message,
+    },
+});
+export class ProtocolVersionGuardTransport {
+    inner;
+    supportedVersions;
+    onclose = () => { };
+    onerror = () => { };
+    onmessage = () => { };
+    sawInitialize = false;
+    ready = false;
+    constructor(inner, supportedVersions) {
+        this.inner = inner;
+        this.supportedVersions = supportedVersions;
+    }
+    setProtocolVersion(version) {
+        this.inner.setProtocolVersion?.(version);
+    }
+    async start() {
+        this.inner.onmessage = (message, extra) => {
+            this.handleMessage(message, extra);
+        };
+        this.inner.onerror = (error) => {
+            this.onerror(error);
+        };
+        this.inner.onclose = () => {
+            this.onclose();
+        };
+        await this.inner.start();
+    }
+    async send(message, options) {
+        await this.inner.send(message, options);
+    }
+    async close() {
+        await this.inner.close();
+    }
+    handleMessage(message, extra) {
+        const initializeInfo = getInitializeInfo(message);
+        if (initializeInfo) {
+            if (this.sawInitialize) {
+                void this.inner.send(createLifecycleError(initializeInfo.id, 'Invalid request: initialize already received'), { relatedRequestId: initializeInfo.id });
+                return;
+            }
+            if (!this.supportedVersions.includes(initializeInfo.protocolVersion)) {
+                void this.inner.send(createUnsupportedVersionError(initializeInfo.id, initializeInfo.protocolVersion, this.supportedVersions), { relatedRequestId: initializeInfo.id });
+                return;
+            }
+            this.sawInitialize = true;
+            this.onmessage(message, extra);
+            return;
+        }
+        if (isInitializedNotification(message)) {
+            if (this.sawInitialize && !this.ready) {
+                this.ready = true;
+                this.onmessage(message, extra);
+            }
+            return;
+        }
+        if (!this.sawInitialize || !this.ready) {
+            if (isJSONRPCRequest(message)) {
+                void this.inner.send(createLifecycleError(message.id, 'Invalid request: initialize must be sent before other requests'), { relatedRequestId: message.id });
+            }
+            else if (isJSONRPCResultResponse(message) ||
+                isJSONRPCErrorResponse(message)) {
+                this.onmessage(message, extra);
+            }
+            return;
+        }
+        this.onmessage(message, extra);
+    }
+}

package/dist/schemas/inputs.d.ts

@@ -42,4 +42,3 @@ export declare const UpdateMemoryInputSchema: z.ZodObject<{
     removeTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export declare const MemoryStatsInputSchema: z.ZodObject<{}, z.core.$strict>;
-//# sourceMappingURL=inputs.d.ts.map

package/dist/schemas/inputs.js

@@ -95,4 +95,3 @@ export const UpdateMemoryInputSchema = z.strictObject({
 export const MemoryStatsInputSchema = z
     .strictObject({})
     .meta({ description: 'No parameters required' });
-//# sourceMappingURL=inputs.js.map

package/dist/schemas/outputs.d.ts

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

package/dist/schemas/outputs.js

@@ -26,4 +26,3 @@ export const DefaultOutputSchema = DefaultOutputSchemaBase.superRefine((value, c
         addIssue(ctx, ['error'], 'error is required when ok is false');
     }
 });
-//# sourceMappingURL=outputs.js.map

package/dist/schemas.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const StoreMemoryInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const SearchMemoriesInputSchema: z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strict>;
+export declare const GetMemoryInputSchema: z.ZodObject<{
+    hash: z.ZodString;
+}, z.core.$strict>;
+export declare const DeleteMemoryInputSchema: z.ZodObject<{
+    hash: z.ZodString;
+}, z.core.$strict>;
+export declare const UpdateMemoryInputSchema: z.ZodObject<{
+    hash: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const MemoryStatsInputSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const DefaultOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/schemas.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+const hashSchema = z.string().regex(/^[a-f0-9]{32}$/i);
+const tagSchema = z
+    .string()
+    .min(1)
+    .max(50)
+    .regex(/^\S+$/, 'Tag must not contain whitespace');
+const tagsSchema = z.array(tagSchema);
+const contentSchema = z.string().min(1).max(100000);
+const querySchema = z.string().trim().min(1).max(1000);
+export const StoreMemoryInputSchema = z.strictObject({
+    content: contentSchema.meta({ description: 'The content of the memory' }),
+    tags: tagsSchema.min(1).max(100).meta({
+        description: 'Tags to categorize the memory (1-100 tags, no whitespace, max 50 chars each)',
+    }),
+});
+export const SearchMemoriesInputSchema = z.strictObject({
+    query: querySchema.meta({
+        description: 'Search query (searches content and tags)',
+    }),
+});
+export const GetMemoryInputSchema = z.strictObject({
+    hash: hashSchema.meta({ description: 'MD5 hash of the memory' }),
+});
+export const DeleteMemoryInputSchema = z.strictObject({
+    hash: hashSchema.meta({ description: 'MD5 hash of the memory' }),
+});
+export const UpdateMemoryInputSchema = z.strictObject({
+    hash: hashSchema.meta({ description: 'MD5 hash of the memory to update' }),
+    content: contentSchema.meta({ description: 'New content for the memory' }),
+    tags: tagsSchema
+        .max(100)
+        .optional()
+        .meta({ description: 'Replace tags (max 100 tags, each max 50 chars)' }),
+});
+export const MemoryStatsInputSchema = z
+    .strictObject({})
+    .meta({ description: 'No parameters required' });
+const ErrorSchema = z.strictObject({
+    code: z.string(),
+    message: z.string(),
+});
+const DefaultOutputSchemaBase = z.strictObject({
+    ok: z.boolean(),
+    result: z.unknown().optional(),
+    error: ErrorSchema.optional(),
+});
+const addIssue = (ctx, path, message) => {
+    ctx.addIssue({
+        code: 'custom',
+        message,
+        path,
+    });
+};
+export const DefaultOutputSchema = DefaultOutputSchemaBase.superRefine((value, ctx) => {
+    if (value.ok) {
+        if (value.error !== undefined) {
+            addIssue(ctx, ['error'], 'error must be absent when ok is true');
+        }
+        return;
+    }
+    if (value.error === undefined) {
+        addIssue(ctx, ['error'], 'error is required when ok is false');
+    }
+});

package/dist/tools/definitions/memory-core.d.ts

@@ -1,3 +1,2 @@
 import type { ToolDef } from '../tool-types.js';
 export declare const coreTools: ToolDef[];
-//# sourceMappingURL=memory-core.d.ts.map

package/dist/tools/definitions/memory-core.js

@@ -77,4 +77,3 @@ export const coreTools = [
         }),
     },
 ];
-//# sourceMappingURL=memory-core.js.map

package/dist/tools/definitions/memory-relations.d.ts

@@ -1,3 +1,2 @@
 import type { ToolDef } from '../tool-types.js';
 export declare const relationTools: ToolDef[];
-//# sourceMappingURL=memory-relations.d.ts.map

package/dist/tools/definitions/memory-relations.js

@@ -41,4 +41,3 @@ export const relationTools = [
         }),
     },
 ];
-//# sourceMappingURL=memory-relations.js.map

package/dist/tools/definitions/memory-search.d.ts

@@ -1,3 +1,2 @@
 import type { ToolDef } from '../tool-types.js';
 export declare const searchTools: ToolDef[];
-//# sourceMappingURL=memory-search.d.ts.map

package/dist/tools/definitions/memory-search.js

@@ -14,17 +14,7 @@ export const searchTools = [
         },
         handler: wrapHandler('E_SEARCH_MEMORIES', (params) => {
             const input = SearchMemoriesInputSchema.parse(params);
-            const searchInput = {
-                query: input.query,
-                limit: input.limit ?? 10,
-                tags: input.tags ?? [],
-                ...(input.minRelevance !== undefined
-                    ? { minRelevance: input.minRelevance }
-                    : {}),
-                ...(input.offset !== undefined ? { offset: input.offset } : {}),
-            };
-            return ok(searchMemories(searchInput));
+            return ok(searchMemories(input));
         }),
     },
 ];
-//# sourceMappingURL=memory-search.js.map