@slorenzot/memento-mcp-server 0.9.0 → 1.0.0

package/dist/index.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -7,6 +40,7 @@ const zod_1 = require("zod");
 const memento_core_1 = require("@slorenzot/memento-core");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const fs = __importStar(require("fs"));
 // Helper function to handle errors in tool execution
 function handleToolError(error) {
     console.error('Tool execution error:', error.message);
@@ -19,11 +53,7 @@ function handleToolError(error) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
-                    success: false,
-                    error: error.message,
-                    hint,
-                }, null, 2),
+                text: JSON.stringify({ success: false, error: error.message, hint }, null, 2),
             },
         ],
     };
@@ -34,17 +64,21 @@ const projectId = (0, memento_core_1.getProjectId)(config);
 const engine = new memento_core_1.MemoryEngine(dbPath);
 let activeSessionId = null;
 const server = new mcp_js_1.McpServer({
-    name: 'memento-mcp-server',
-    version: '0.4.0',
+    name: 'memento',
+    version: '1.0.0',
 });
-server.tool('mem_save', 'Save an observation to memory. Types: decision, bug, discovery, note.', {
-    title: zod_1.z.string().describe('Title of observation'),
-    content: zod_1.z.string().describe('Content of observation'),
+// ─── Observation Tools ──────────────────────────────────────
+server.tool('memento_mem_save', 'Save an observation to persistent memory. Types: decision, bug, discovery, note. Call this PROACTIVELY after making decisions, fixing bugs, or discovering something non-obvious.', {
+    title: zod_1.z.string().describe('Short, searchable title (e.g. "Fixed N+1 in UserList")'),
+    content: zod_1.z.string().describe('Structured content: What/Why/Where/Learned format'),
     type: zod_1.z
         .enum(['decision', 'bug', 'discovery', 'note'])
         .optional()
         .describe('Type of observation (default: note)'),
-    topic_key: zod_1.z.string().optional().describe('Topic key for grouping'),
+    topic_key: zod_1.z
+        .string()
+        .optional()
+        .describe('Stable topic key for grouping (e.g. "architecture/auth-model")'),
     project_id: zod_1.z.string().optional().describe('Project identifier'),
     metadata: zod_1.z.record(zod_1.z.unknown()).optional().describe('Additional metadata'),
 }, async ({ title, content, type, topic_key, project_id, metadata }) => {
@@ -82,185 +116,362 @@ server.tool('mem_save', 'Save an observation to memory. Types: decision, bug, di
         return handleToolError(error);
     }
 });
-server.tool('mem_search', 'Search observations using text matching.', {
-    query: zod_1.z.string().optional().describe('Search query'),
+server.tool('memento_mem_search', 'Search observations using full-text search (FTS5). Start with small limits and expand only if needed.', {
+    query: zod_1.z.string().optional().describe('Search query (FTS5 syntax)'),
     type: zod_1.z.enum(['decision', 'bug', 'discovery', 'note']).optional(),
     project_id: zod_1.z.string().optional(),
     topic_key: zod_1.z.string().optional(),
-    limit: zod_1.z.number().optional(),
+    limit: zod_1.z.number().optional().describe('Max results (default: 10)'),
     offset: zod_1.z.number().optional(),
-}, async ({ query, type, project_id, topic_key, limit, offset }) => {
+    include_deleted: zod_1.z.boolean().optional().describe('Include soft-deleted observations'),
+}, async ({ query, type, project_id, topic_key, limit, offset, include_deleted }) => {
     try {
         const result = await engine.search({
             query,
             type: type,
             projectId: project_id,
             topicKey: topic_key,
-            limit,
+            limit: limit || 10,
             offset,
+            includeDeleted: include_deleted,
         });
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     }
     catch (error) {
         return handleToolError(error);
     }
 });
-server.tool('mem_get_observation', 'Get a specific observation by ID.', {
+server.tool('memento_mem_get_observation', 'Get full content of a specific observation by ID.', {
     id: zod_1.z.number().describe('Observation ID'),
 }, async ({ id }) => {
-    const obs = await engine.getObservation(id);
-    if (!obs)
-        throw new Error(`Observation ${id} not found`);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(obs, null, 2) }],
-    };
+    try {
+        const obs = await engine.getObservation(id);
+        if (!obs)
+            throw new Error(`Observation ${id} not found`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(obs, null, 2) }],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_update', 'Update an existing observation.', {
+server.tool('memento_mem_update', 'Update an existing observation.', {
     id: zod_1.z.number().describe('Observation ID'),
     title: zod_1.z.string().optional(),
     content: zod_1.z.string().optional(),
     type: zod_1.z.enum(['decision', 'bug', 'discovery', 'note']).optional(),
     topic_key: zod_1.z.string().optional(),
 }, async ({ id, title, content, type, topic_key }) => {
-    const updated = await engine.updateObservation(id, {
-        title,
-        content,
-        type: type,
-        topicKey: topic_key,
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ id: updated.id, success: true }, null, 2),
-            },
-        ],
-    };
+    try {
+        const updated = await engine.updateObservation(id, {
+            title,
+            content,
+            type: type,
+            topicKey: topic_key,
+        });
+        return {
+            content: [
+                { type: 'text', text: JSON.stringify({ id: updated.id, success: true }, null, 2) },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_delete', 'Delete an observation.', {
-    id: zod_1.z.number().describe('Observation ID'),
+// ─── Soft Delete / Restore / Purge ──────────────────────────
+server.tool('memento_mem_delete', 'Soft-delete an observation. The record is hidden from searches but can be restored with memento_mem_restore. Use memento_mem_purge for permanent deletion.', {
+    id: zod_1.z.number().describe('Observation ID to soft-delete'),
+    reason: zod_1.z.string().optional().describe('Reason for deletion (stored in metadata)'),
+}, async ({ id, reason }) => {
+    try {
+        await engine.deleteObservation(id, reason);
+        return {
+            content: [
+                { type: 'text', text: JSON.stringify({ id, deleted: true, success: true }, null, 2) },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
+});
+server.tool('memento_mem_restore', 'Restore a soft-deleted observation back to active state.', {
+    id: zod_1.z.number().describe('Observation ID to restore'),
 }, async ({ id }) => {
-    await engine.deleteObservation(id);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ id, success: true }, null, 2),
-            },
-        ],
-    };
+    try {
+        const restored = await engine.restoreObservation(id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ id: restored.id, restored: true, success: true }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
+});
+server.tool('memento_mem_purge', 'PERMANENTLY delete soft-deleted observations. This is IRREVERSIBLE. Requires confirm: true.', {
+    confirm: zod_1.z.boolean().describe('Must be true to execute purge'),
+    project_id: zod_1.z.string().optional().describe('Purge all deleted obs in this project'),
+    observation_ids: zod_1.z
+        .array(zod_1.z.number())
+        .optional()
+        .describe('Specific soft-deleted observation IDs to purge'),
+}, async ({ confirm, project_id, observation_ids }) => {
+    try {
+        if (!confirm) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: 'confirm must be true to execute purge' }, null, 2),
+                    },
+                ],
+            };
+        }
+        const result = await engine.purgeObservations({
+            projectId: project_id,
+            observationIds: observation_ids,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ ...result, success: true }, null, 2) }],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
+});
+server.tool('memento_mem_list_deleted', 'List soft-deleted observations that can be restored or purged.', {
+    project_id: zod_1.z.string().optional(),
+    limit: zod_1.z.number().optional().describe('Max results (default: 20)'),
+}, async ({ project_id, limit }) => {
+    try {
+        const result = await engine.listDeleted({ projectId: project_id, limit });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
+});
+// ─── Merge ──────────────────────────────────────────────────
+server.tool('memento_mem_merge', 'Merge related observations into a single synthesized record. Identifies candidates automatically by topic_key or content similarity (Jaccard > 0.85). Use dry_run to preview without executing.', {
+    project_id: zod_1.z.string().describe('Project to merge observations in (required)'),
+    topic_key: zod_1.z.string().optional().describe('Merge all observations with this topic_key'),
+    observation_ids: zod_1.z
+        .array(zod_1.z.number())
+        .optional()
+        .describe('Specific observation IDs to merge (overrides auto-detection)'),
+    strategy: zod_1.z
+        .enum(['by_topic', 'by_similarity', 'by_ids'])
+        .optional()
+        .describe('Merge strategy (default: by_topic)'),
+    dry_run: zod_1.z.boolean().optional().describe('If true, returns candidates without executing merge'),
+}, async ({ project_id, topic_key, observation_ids, strategy, dry_run }) => {
+    try {
+        const results = await engine.mergeObservations({
+            projectId: project_id,
+            topicKey: topic_key,
+            observationIds: observation_ids,
+            strategy: strategy || 'by_topic',
+            dryRun: dry_run,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        dryRun: dry_run || false,
+                        mergeCount: results.length,
+                        results: results.map((r) => ({
+                            mergedObservationId: r.mergedObservation.id,
+                            deletedIds: r.deletedIds,
+                            originalCount: r.originalCount,
+                            strategy: r.strategy,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
+});
+// ─── Export ──────────────────────────────────────────────────
+server.tool('memento_mem_export', 'Export observations to JSON, XML, or TXT format. Use filters to reduce scope.', {
+    format: zod_1.z.enum(['json', 'xml', 'txt']).optional().describe('Export format (default: json)'),
+    project_id: zod_1.z.string().optional().describe('Filter by project'),
+    type: zod_1.z.enum(['decision', 'bug', 'discovery', 'note']).optional(),
+    topic_key: zod_1.z.string().optional(),
+    date_from: zod_1.z.string().optional().describe('ISO date string — export from this date'),
+    date_to: zod_1.z.string().optional().describe('ISO date string — export until this date'),
+    include_deleted: zod_1.z.boolean().optional().describe('Include soft-deleted observations'),
+}, async ({ format, project_id, type, topic_key, date_from, date_to, include_deleted }) => {
+    try {
+        const result = await engine.exportObservations({
+            format: format || 'json',
+            projectId: project_id,
+            type: type,
+            topicKey: topic_key,
+            dateFrom: date_from ? new Date(date_from) : undefined,
+            dateTo: date_to ? new Date(date_to) : undefined,
+            includeDeleted: include_deleted,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        format: result.format,
+                        recordCount: result.recordCount,
+                        exportedAt: result.exportedAt.toISOString(),
+                        content: result.content,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_session_start', 'Start a new memory session.', {
+// ─── Session Tools ──────────────────────────────────────────
+server.tool('memento_mem_session_start', 'Start a new memory session for tracking a coding conversation.', {
     project_id: zod_1.z.string().describe('Project identifier'),
     metadata: zod_1.z.record(zod_1.z.unknown()).optional(),
 }, async ({ project_id, metadata }) => {
-    const session = await engine.createSession({
-        projectId: project_id,
-        endedAt: null,
-        metadata: metadata || {},
-    });
-    activeSessionId = session.id;
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ id: session.id, uuid: session.uuid, success: true }, null, 2),
-            },
-        ],
-    };
+    try {
+        const session = await engine.createSession({
+            projectId: project_id,
+            endedAt: null,
+            metadata: metadata || {},
+        });
+        activeSessionId = session.id;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ id: session.id, uuid: session.uuid, success: true }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_session_end', 'End current active session.', {}, async () => {
-    if (!activeSessionId)
-        throw new Error('No active session');
-    const ended = await engine.endSession(activeSessionId);
-    activeSessionId = null;
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ id: ended.id, uuid: ended.uuid, endedAt: ended.endedAt, success: true }, null, 2),
-            },
-        ],
-    };
+server.tool('memento_mem_session_end', 'End current active session.', {}, async () => {
+    try {
+        if (!activeSessionId)
+            throw new Error('No active session');
+        const ended = await engine.endSession(activeSessionId);
+        activeSessionId = null;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ id: ended.id, uuid: ended.uuid, endedAt: ended.endedAt, success: true }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_list_sessions', 'List all sessions.', {
+server.tool('memento_mem_list_sessions', 'List all sessions.', {
     project_id: zod_1.z.string().optional(),
     limit: zod_1.z.number().optional(),
 }, async ({ project_id, limit }) => {
-    const result = await engine.search({
-        projectId: project_id,
-        limit: limit || 20,
-    });
-    const uniqueSessions = new Set(result.observations.map((o) => o.sessionId));
-    const sessions = await Promise.all(Array.from(uniqueSessions).map((id) => engine.getSession(id)));
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ sessions: sessions.filter(Boolean), total: sessions.length }, null, 2),
-            },
-        ],
-    };
+    try {
+        const result = await engine.search({ projectId: project_id, limit: limit || 20 });
+        const uniqueSessions = new Set(result.observations.map((o) => o.sessionId));
+        const sessions = await Promise.all(Array.from(uniqueSessions).map((id) => engine.getSession(id)));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ sessions: sessions.filter(Boolean), total: sessions.length }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_get_session', 'Get a specific session by ID.', {
+server.tool('memento_mem_get_session', 'Get a specific session by ID.', {
     id: zod_1.z.number().describe('Session ID'),
 }, async ({ id }) => {
-    const s = await engine.getSession(id);
-    if (!s)
-        throw new Error(`Session ${id} not found`);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(s, null, 2) }],
-    };
+    try {
+        const s = await engine.getSession(id);
+        if (!s)
+            throw new Error(`Session ${id} not found`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(s, null, 2) }],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_timeline', 'Get chronological timeline of observations.', {
+// ─── Utility Tools ──────────────────────────────────────────
+server.tool('memento_mem_timeline', 'Get chronological timeline of observations.', {
     project_id: zod_1.z.string().optional(),
     limit: zod_1.z.number().optional(),
     offset: zod_1.z.number().optional(),
 }, async ({ project_id, limit, offset }) => {
-    const result = await engine.search({
-        projectId: project_id,
-        limit,
-        offset,
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(result, null, 2),
-            },
-        ],
-    };
+    try {
+        const result = await engine.search({ projectId: project_id, limit, offset });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
-server.tool('mem_stats', 'Get memory statistics.', {}, async () => {
-    const result = await engine.search({});
-    const byType = {};
-    const byProject = {};
-    for (const o of result.observations) {
-        byType[o.type] = (byType[o.type] || 0) + 1;
-        byProject[o.projectId] = (byProject[o.projectId] || 0) + 1;
+server.tool('memento_mem_stats', 'Get memory statistics.', {}, async () => {
+    try {
+        const result = await engine.search({});
+        const deleted = await engine.listDeleted({});
+        const byType = {};
+        const byProject = {};
+        for (const o of result.observations) {
+            byType[o.type] = (byType[o.type] || 0) + 1;
+            byProject[o.projectId] = (byProject[o.projectId] || 0) + 1;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        totalObservations: result.total,
+                        deletedObservations: deleted.total,
+                        byType,
+                        byProject,
+                        activeSessionId,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
     }
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({
-                    totalObservations: result.total,
-                    byType,
-                    byProject,
-                    activeSessionId,
-                }, null, 2),
-            },
-        ],
-    };
 });
-server.tool('mem_health', 'Check system health.', {}, async () => {
+server.tool('memento_mem_health', 'Check system health.', {}, async () => {
     try {
         const isHealthy = engine.isHealthy();
         const result = isHealthy ? await engine.search({}) : { total: 0, observations: [] };
@@ -271,7 +482,7 @@ server.tool('mem_health', 'Check system health.', {}, async () => {
                     type: 'text',
                     text: JSON.stringify({
                         status: isHealthy ? 'healthy' : 'unhealthy',
-                        version: '0.7.0',
+                        version: '1.0.0',
                         storage: 'sqlite-persistent',
                         databasePath: dbPath,
                         projectId: projectId,
@@ -288,77 +499,99 @@ server.tool('mem_health', 'Check system health.', {}, async () => {
         return handleToolError(error);
     }
 });
-server.tool('mem_config', 'Get current memento configuration and system status.', {}, async () => {
-    const searchResult = await engine.search({});
-    const dbPath = engine.getDatabasePath();
-    const byType = {};
-    for (const o of searchResult.observations) {
-        byType[o.type] = (byType[o.type] || 0) + 1;
-    }
-    const dbStats = getDatabaseStats(dbPath);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({
-                    name: 'memento-mcp-server',
-                    version: '0.5.0',
-                    config: {
-                        storagePath: dbPath,
-                        projectId: projectId,
-                        projectRoot: process.cwd(),
-                        hasConfigFile: (0, fs_1.existsSync)((0, path_1.join)(process.cwd(), '.mementorc')),
-                    },
-                    storage: {
-                        type: 'SQLite Persistent',
-                        method: 'bun:sqlite',
-                        databasePath: dbPath,
-                        walEnabled: true,
-                    },
-                    diskUsage: dbStats,
-                    statistics: {
-                        totalObservations: searchResult.total,
-                        byType,
-                        activeSession: activeSessionId,
-                    },
-                    environment: {
-                        nodeVersion: process.version,
-                        platform: process.platform,
-                        arch: process.arch,
-                        bunVersion: process.versions?.bun || 'unknown',
-                    },
-                }, null, 2),
-            },
-        ],
-    };
+server.tool('memento_mem_config', 'Get current memento configuration and system status.', {}, async () => {
+    try {
+        const searchResult = await engine.search({});
+        const currentDbPath = engine.getDatabasePath();
+        const byType = {};
+        for (const o of searchResult.observations) {
+            byType[o.type] = (byType[o.type] || 0) + 1;
+        }
+        const dbStats = getDatabaseStats(currentDbPath);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        name: 'memento',
+                        version: '1.0.0',
+                        config: {
+                            storagePath: currentDbPath,
+                            projectId: projectId,
+                            projectRoot: process.cwd(),
+                            hasConfigFile: (0, fs_1.existsSync)((0, path_1.join)(process.cwd(), '.mementorc')),
+                        },
+                        storage: {
+                            type: 'SQLite Persistent',
+                            method: 'bun:sqlite',
+                            databasePath: currentDbPath,
+                            walEnabled: true,
+                        },
+                        diskUsage: dbStats,
+                        statistics: {
+                            totalObservations: searchResult.total,
+                            byType,
+                            activeSession: activeSessionId,
+                        },
+                        environment: {
+                            nodeVersion: process.version,
+                            platform: process.platform,
+                            arch: process.arch,
+                            bunVersion: process.versions?.bun || 'unknown',
+                        },
+                        tools: [
+                            'memento_mem_save',
+                            'memento_mem_search',
+                            'memento_mem_get_observation',
+                            'memento_mem_update',
+                            'memento_mem_delete',
+                            'memento_mem_restore',
+                            'memento_mem_purge',
+                            'memento_mem_list_deleted',
+                            'memento_mem_merge',
+                            'memento_mem_export',
+                            'memento_mem_session_start',
+                            'memento_mem_session_end',
+                            'memento_mem_list_sessions',
+                            'memento_mem_get_session',
+                            'memento_mem_timeline',
+                            'memento_mem_stats',
+                            'memento_mem_health',
+                            'memento_mem_config',
+                        ],
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleToolError(error);
+    }
 });
+// ─── Helpers ────────────────────────────────────────────────
 function getDatabaseStats(dbPath) {
-    const fs = require('fs');
     let totalSize = 0;
     let walSize = 0;
     let shmSize = 0;
     try {
-        const mainDb = fs.statSync(dbPath);
-        totalSize += mainDb.size;
+        totalSize += fs.statSync(dbPath).size;
     }
-    catch (e) {
-        totalSize += 0;
+    catch {
+        /* empty */
     }
     try {
-        const walFile = fs.statSync(`${dbPath}-wal`);
-        walSize = walFile.size;
+        walSize = fs.statSync(`${dbPath}-wal`).size;
         totalSize += walSize;
     }
-    catch (e) {
-        walSize = 0;
+    catch {
+        /* empty */
     }
     try {
-        const shmFile = fs.statSync(`${dbPath}-shm`);
-        shmSize = shmFile.size;
+        shmSize = fs.statSync(`${dbPath}-shm`).size;
         totalSize += shmSize;
     }
-    catch (e) {
-        shmSize = 0;
+    catch {
+        /* empty */
     }
     return {
         totalBytes: totalSize,
@@ -367,8 +600,6 @@ function getDatabaseStats(dbPath) {
         mainDbSizeHuman: formatBytes(totalSize - walSize - shmSize),
         walBytes: walSize,
         walSizeHuman: formatBytes(walSize),
-        shmBytes: shmSize,
-        shmSizeHuman: formatBytes(shmSize),
     };
 }
 function formatBytes(bytes) {
@@ -385,38 +616,27 @@ function formatBytes(bytes) {
         return `${(bytes / m).toFixed(2)} MB`;
     return `${(bytes / g).toFixed(2)} GB`;
 }
+// ─── Server Startup ─────────────────────────────────────────
 const BANNER = `
- ╔═════════════════════════════════════════════════════════╗
- ║                                                               ║
- ║     ██╗    ██╗███████╗██╗   ██╗██╗███╗   ███████╗               ║
- ║     ██║    ██║██╔════╝██║   ██║██║██╔██╗ ██╔════╝               ║
- ║     ██║ █╗ ██║█████╗  ██║   ██║██║███████║███████╗                ║
- ║     ╚███╔╝██╚════██╗██║   ██║██║╚════██║╚════██║                ║
- ║      ╚══╝ ╚███████╔╝╚█████╔╝╚█████╔╝ ╚███████╔╝               ║
- ║                  ╚═════╝     ╚═════╝     ╚═════╝                ║
- ║                                                               ║
- ║              ╔═══════════════════════════════════════╗   ║
- ║              ║                                           ║   ║
- ║              ║    MEMENTO - Persistent Memory System      ║   ║
- ║              ║                                           ║   ║
- ║              ║    Version: 0.5.0                         ║   ║
- ║              ║    Storage: SQLite Persistent              ║   ║
- ║              ╚═══════════════════════════════════════╝   ║
- ╚═════════════════════════════════════════════════════════╝
+ ╔══════════════════════════════════════════════════╗
+ ║                                                  ║
+ ║     MEMENTO — Persistent Memory System           ║
+ ║                                                  ║
+ ║     Version: 1.0.0                               ║
+ ║     MCP Server: memento                          ║
+ ║     Storage: SQLite Persistent                   ║
+ ║     Tools: memento_mem_*                         ║
+ ║                                                  ║
+ ╚══════════════════════════════════════════════════╝
 `;
 async function main() {
     console.error(BANNER);
-    // Check database health and show warnings if needed
     if (!engine.isHealthy()) {
         const initError = engine.getInitError();
         console.error('\n⚠️  WARNING: Database initialization failed');
         console.error(`   Error: ${initError?.message || 'Unknown error'}`);
         console.error(`   Database path: ${dbPath}`);
         console.error('\n   The server will start, but database operations will fail.');
-        console.error('   Please check:');
-        console.error('   - Directory permissions');
-        console.error('   - Disk space');
-        console.error('   - Path configuration in .mementorc\n');
     }
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
@@ -424,11 +644,11 @@ async function main() {
     console.error(`  Database: ${dbPath}`);
     console.error(`  Project: ${projectId}`);
     console.error(`  Health: ${engine.isHealthy() ? '✓ Healthy' : '✗ Unhealthy'}`);
+    console.error(`  Tools: 18 (memento_mem_*)`);
     console.error(`  Ready to accept connections...\n`);
 }
 main().catch((err) => {
     console.error('Fatal error during server startup:', err);
-    console.error('\nThe server failed to start. Please check the error above.');
     process.exit(1);
 });
 //# sourceMappingURL=index.js.map