sqlew 3.2.5 → 3.6.0

package/dist/index.js

@@ -6,16 +6,21 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { initializeDatabase, closeDatabase, setConfigValue, getAllConfig } from './database.js';
+import { initializeDatabase, closeDatabase, setConfigValue, getAllConfig, getAdapter } from './database.js';
 import { CONFIG_KEYS } from './constants.js';
+import { loadConfigFile } from './config/loader.js';
 import { setDecision, getContext, getDecision, searchByTags, getVersions, searchByLayer, quickSetDecision, searchAdvanced, setDecisionBatch, hasUpdates, setFromTemplate, createTemplate, listTemplates, hardDeleteDecision, addDecisionContextAction, listDecisionContextsAction, decisionHelp, decisionExample } from './tools/context.js';
 import { sendMessage, getMessages, markRead, sendMessageBatch, messageHelp, messageExample } from './tools/messaging.js';
 import { recordFileChange, getFileChanges, checkFileLock, recordFileChangeBatch, fileHelp, fileExample } from './tools/files.js';
 import { addConstraint, getConstraints, deactivateConstraint, constraintHelp, constraintExample } from './tools/constraints.js';
 import { getLayerSummary, clearOldData, getStats, getActivityLog, flushWAL, statsHelp, statsExample } from './tools/utils.js';
 import { getConfig, updateConfig, configHelp, configExample } from './tools/config.js';
-import { createTask, updateTask, getTask, listTasks, moveTask, linkTask, archiveTask, batchCreateTasks, addDependency, removeDependency, getDependencies, taskHelp, taskExample, watcherStatus } from './tools/tasks.js';
+import { createTask, updateTask, getTask, listTasks, moveTask, linkTask, archiveTask, batchCreateTasks, addDependency, removeDependency, getDependencies, watchFiles, getPrunedFiles, linkPrunedFile, taskHelp, taskExample, watcherStatus } from './tools/tasks.js';
 import { FileWatcher } from './watcher/index.js';
+import { trackAndReturnHelp } from './utils/help-tracking.js';
+import { queryHelpAction, queryHelpParams, queryHelpTool, queryHelpUseCase, queryHelpListUseCases, queryHelpNextActions } from './tools/help-queries.js';
+import { initDebugLogger, closeDebugLogger, debugLog, debugLogToolCall, debugLogToolResponse, debugLogError } from './utils/debug-logger.js';
+import { ensureSqlewDirectory } from './config/example-generator.js';
 // Parse command-line arguments
 const args = process.argv.slice(2);
 const parsedArgs = {};
@@ -46,6 +51,12 @@ for (let i = 0; i < args.length; i++) {
     else if (arg === '--autodelete-file-history-days' && i + 1 < args.length) {
         parsedArgs.autodeleteFileHistoryDays = parseInt(args[++i], 10);
     }
+    else if (arg.startsWith('--debug-log=')) {
+        parsedArgs.debugLogPath = arg.split('=')[1];
+    }
+    else if (arg === '--debug-log' && i + 1 < args.length) {
+        parsedArgs.debugLogPath = args[++i];
+    }
     else if (!arg.startsWith('--')) {
         // Backward compatibility: first non-flag argument is dbPath
         if (!parsedArgs.dbPath) {
@@ -53,33 +64,12 @@ for (let i = 0; i < args.length; i++) {
         }
     }
 }
-const dbPath = parsedArgs.dbPath;
-// Initialize database
+// Load config file and determine database path
+// Priority: CLI --db-path > config file > default
+const fileConfig = loadConfigFile();
+const dbPath = parsedArgs.dbPath || fileConfig.database?.path;
+// Initialize database (will be set after async init completes)
 let db;
-try {
-    db = initializeDatabase(dbPath);
-    // Apply CLI config overrides if provided
-    if (parsedArgs.autodeleteIgnoreWeekend !== undefined) {
-        setConfigValue(db, CONFIG_KEYS.AUTODELETE_IGNORE_WEEKEND, parsedArgs.autodeleteIgnoreWeekend ? '1' : '0');
-    }
-    if (parsedArgs.autodeleteMessageHours !== undefined) {
-        setConfigValue(db, CONFIG_KEYS.AUTODELETE_MESSAGE_HOURS, String(parsedArgs.autodeleteMessageHours));
-    }
-    if (parsedArgs.autodeleteFileHistoryDays !== undefined) {
-        setConfigValue(db, CONFIG_KEYS.AUTODELETE_FILE_HISTORY_DAYS, String(parsedArgs.autodeleteFileHistoryDays));
-    }
-    // Display current config
-    const config = getAllConfig(db);
-    const ignoreWeekend = config[CONFIG_KEYS.AUTODELETE_IGNORE_WEEKEND] === '1';
-    const messageHours = config[CONFIG_KEYS.AUTODELETE_MESSAGE_HOURS];
-    const fileHistoryDays = config[CONFIG_KEYS.AUTODELETE_FILE_HISTORY_DAYS];
-    console.error('✓ MCP Shared Context Server initialized');
-    console.error(`  Auto-delete config: messages=${messageHours}h, file_history=${fileHistoryDays}d, ignore_weekend=${ignoreWeekend}`);
-}
-catch (error) {
-    console.error('✗ Failed to initialize database:', error);
-    process.exit(1);
-}
 // Create MCP server
 const server = new Server({
     name: 'mcp-sqlew',
@@ -108,47 +98,7 @@ Use action: "example" for comprehensive usage examples.`,
                             type: 'string',
                             description: 'Action',
                             enum: ['set', 'get', 'list', 'search_tags', 'search_layer', 'versions', 'quick_set', 'search_advanced', 'set_batch', 'has_updates', 'set_from_template', 'create_template', 'list_templates', 'hard_delete', 'add_decision_context', 'list_decision_contexts', 'help', 'example']
-                        },
-                        key: { type: 'string' },
-                        value: { type: ['string', 'number'] },
-                        agent: { type: 'string' },
-                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
-                        version: { type: 'string' },
-                        status: { type: 'string', enum: ['active', 'deprecated', 'draft'] },
-                        tags: { type: 'array', items: { type: 'string' } },
-                        scopes: { type: 'array', items: { type: 'string' } },
-                        scope: { type: 'string' },
-                        tag_match: { type: 'string', enum: ['AND', 'OR'] },
-                        include_tags: { type: 'boolean' },
-                        layers: { type: 'array', items: { type: 'string' } },
-                        tags_all: { type: 'array', items: { type: 'string' } },
-                        tags_any: { type: 'array', items: { type: 'string' } },
-                        exclude_tags: { type: 'array', items: { type: 'string' } },
-                        updated_after: { type: 'string' },
-                        updated_before: { type: 'string' },
-                        decided_by: { type: 'array', items: { type: 'string' } },
-                        statuses: { type: 'array', items: { type: 'string', enum: ['active', 'deprecated', 'draft'] } },
-                        search_text: { type: 'string' },
-                        sort_by: { type: 'string', enum: ['updated', 'key', 'version'] },
-                        sort_order: { type: 'string', enum: ['asc', 'desc'] },
-                        limit: { type: 'number' },
-                        offset: { type: 'number' },
-                        decisions: { type: 'array' },
-                        atomic: { type: 'boolean' },
-                        agent_name: { type: 'string' },
-                        since_timestamp: { type: 'string' },
-                        template: { type: 'string' },
-                        name: { type: 'string' },
-                        defaults: { type: 'object' },
-                        required_fields: { type: 'array', items: { type: 'string' } },
-                        created_by: { type: 'string' },
-                        rationale: { type: 'string' },
-                        alternatives_considered: { type: ['array', 'string'] },
-                        tradeoffs: { type: ['object', 'string'] },
-                        decision_key: { type: 'string' },
-                        related_task_id: { type: 'number' },
-                        related_constraint_id: { type: 'number' },
-                        include_context: { type: 'boolean' },
+                        }
                     },
                     required: ['action'],
                 },
@@ -164,22 +114,11 @@ Use action: "example" for comprehensive usage examples.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['send', 'get', 'mark_read', 'send_batch', 'help', 'example'] },
-                        agent_name: { type: 'string' },
-                        from_agent: { type: 'string' },
-                        to_agent: { type: ['string', 'null'] },
-                        msg_type: { type: 'string', enum: ['decision', 'warning', 'request', 'info'] },
-                        message: { type: 'string' },
-                        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], default: 'medium' },
-                        payload: { type: 'object' },
-                        message_ids: { type: 'array', items: { type: 'number' } },
-                        unread_only: { type: 'boolean', default: false },
-                        msg_type_filter: { type: 'string', enum: ['decision', 'warning', 'request', 'info'] },
-                        priority_filter: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-                        limit: { type: 'number', default: 50 },
-                        // send_batch parameters
-                        messages: { type: 'array', description: 'Array of messages for batch operation (max: 50)' },
-                        atomic: { type: 'boolean', description: 'Atomic mode - all succeed or all fail (default: true)' },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['send', 'get', 'mark_read', 'send_batch', 'help', 'example']
+                        }
                     },
                     required: ['action'],
                 },
@@ -195,18 +134,11 @@ Use action: "example" for comprehensive usage examples.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['record', 'get', 'check_lock', 'record_batch', 'help', 'example'] },
-                        file_path: { type: 'string' },
-                        agent_name: { type: 'string' },
-                        change_type: { type: 'string', enum: ['created', 'modified', 'deleted'] },
-                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
-                        description: { type: 'string' },
-                        since: { type: 'string' },
-                        limit: { type: 'number' },
-                        lock_duration: { type: 'number' },
-                        // record_batch parameters
-                        file_changes: { type: 'array', description: 'Array of file changes for batch operation (max: 50)' },
-                        atomic: { type: 'boolean', description: 'Atomic mode - all succeed or all fail (default: true)' },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['record', 'get', 'check_lock', 'record_batch', 'help', 'example']
+                        }
                     },
                     required: ['action'],
                 },
@@ -222,16 +154,11 @@ Use action: "example" for comprehensive usage examples.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['add', 'get', 'deactivate', 'help', 'example'] },
-                        constraint_id: { type: 'number' },
-                        category: { type: 'string', enum: ['performance', 'architecture', 'security'] },
-                        constraint_text: { type: 'string' },
-                        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], default: 'medium' },
-                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
-                        tags: { type: 'array', items: { type: 'string' } },
-                        created_by: { type: 'string' },
-                        active_only: { type: 'boolean', default: true },
-                        limit: { type: 'number', default: 50 },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['add', 'get', 'deactivate', 'help', 'example']
+                        }
                     },
                     required: ['action'],
                 },
@@ -247,13 +174,11 @@ Use action: "example" for comprehensive usage examples.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['layer_summary', 'db_stats', 'clear', 'activity_log', 'flush', 'help', 'example'] },
-                        messages_older_than_hours: { type: 'number' },
-                        file_changes_older_than_days: { type: 'number' },
-                        since: { type: 'string', description: 'Time filter (e.g., "5m", "1h", "2d" or ISO timestamp)' },
-                        agent_names: { type: 'array', items: { type: 'string' }, description: 'Filter by agents' },
-                        actions: { type: 'array', items: { type: 'string' }, description: 'Filter by action types' },
-                        limit: { type: 'number', description: 'Max results (default: 100)' },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['layer_summary', 'db_stats', 'clear', 'activity_log', 'flush', 'help_action', 'help_params', 'help_tool', 'help_use_case', 'help_list_use_cases', 'help_next_actions', 'help', 'example']
+                        }
                     },
                     required: ['action'],
                 },
@@ -269,10 +194,11 @@ Use action: "example" for comprehensive usage examples.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['get', 'update', 'help', 'example'] },
-                        ignoreWeekend: { type: 'boolean' },
-                        messageRetentionHours: { type: 'number', minimum: 1, maximum: 168 },
-                        fileHistoryRetentionDays: { type: 'number', minimum: 1, maximum: 90 },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['get', 'update', 'help', 'example']
+                        }
                     },
                     required: ['action'],
                 },
@@ -288,27 +214,11 @@ Use action: "example" for comprehensive usage examples.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        action: { type: 'string', description: 'Action (use "help" for usage)', enum: ['create', 'update', 'get', 'list', 'move', 'link', 'archive', 'batch_create', 'help', 'example'] },
-                        task_id: { type: 'number' },
-                        title: { type: 'string' },
-                        description: { type: 'string' },
-                        acceptance_criteria: { type: 'string' },
-                        notes: { type: 'string' },
-                        priority: { type: 'number', minimum: 1, maximum: 4 },
-                        assigned_agent: { type: 'string' },
-                        created_by_agent: { type: 'string' },
-                        layer: { type: 'string', enum: ['presentation', 'business', 'data', 'infrastructure', 'cross-cutting'] },
-                        tags: { type: 'array', items: { type: 'string' } },
-                        status: { type: 'string', enum: ['todo', 'in_progress', 'waiting_review', 'blocked', 'done', 'archived'] },
-                        new_status: { type: 'string', enum: ['todo', 'in_progress', 'waiting_review', 'blocked', 'done', 'archived'] },
-                        link_type: { type: 'string', enum: ['decision', 'constraint', 'file'] },
-                        target_id: { type: ['string', 'number'] },
-                        link_relation: { type: 'string' },
-                        limit: { type: 'number', default: 50 },
-                        offset: { type: 'number', default: 0 },
-                        // batch_create parameters
-                        tasks: { type: 'array', description: 'Array of tasks for batch operation (max: 50)' },
-                        atomic: { type: 'boolean', description: 'Atomic mode - all succeed or all fail (default: true)' },
+                        action: {
+                            type: 'string',
+                            description: 'Action',
+                            enum: ['create', 'update', 'get', 'list', 'move', 'link', 'archive', 'batch_create', 'add_dependency', 'remove_dependency', 'get_dependencies', 'watch_files', 'watcher', 'help', 'example']
+                        }
                     },
                     required: ['action'],
                 },
@@ -320,6 +230,9 @@ Use action: "example" for comprehensive usage examples.`,
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const params = args;
+    const action = params.action || 'N/A';
+    // Debug logging: Tool call
+    debugLogToolCall(name, action, params);
     try {
         let result;
         switch (name) {
@@ -389,10 +302,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         result = listDecisionContextsAction(params);
                         break;
                     case 'help':
-                        result = decisionHelp();
+                        const helpContent = decisionHelp();
+                        trackAndReturnHelp('decision', 'help', JSON.stringify(helpContent));
+                        result = helpContent;
                         break;
                     case 'example':
-                        result = decisionExample();
+                        const exampleContent = decisionExample();
+                        trackAndReturnHelp('decision', 'example', JSON.stringify(exampleContent));
+                        result = exampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -412,10 +329,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         result = sendMessageBatch({ messages: params.messages, atomic: params.atomic });
                         break;
                     case 'help':
-                        result = messageHelp();
+                        const msgHelpContent = messageHelp();
+                        trackAndReturnHelp('message', 'help', JSON.stringify(msgHelpContent));
+                        result = msgHelpContent;
                         break;
                     case 'example':
-                        result = messageExample();
+                        const msgExampleContent = messageExample();
+                        trackAndReturnHelp('message', 'example', JSON.stringify(msgExampleContent));
+                        result = msgExampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -435,10 +356,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         result = recordFileChangeBatch({ file_changes: params.file_changes, atomic: params.atomic });
                         break;
                     case 'help':
-                        result = fileHelp();
+                        const fileHelpContent = fileHelp();
+                        trackAndReturnHelp('file', 'help', JSON.stringify(fileHelpContent));
+                        result = fileHelpContent;
                         break;
                     case 'example':
-                        result = fileExample();
+                        const fileExampleContent = fileExample();
+                        trackAndReturnHelp('file', 'example', JSON.stringify(fileExampleContent));
+                        result = fileExampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -455,10 +380,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         result = deactivateConstraint(params);
                         break;
                     case 'help':
-                        result = constraintHelp();
+                        const constraintHelpContent = constraintHelp();
+                        trackAndReturnHelp('constraint', 'help', JSON.stringify(constraintHelpContent));
+                        result = constraintHelpContent;
                         break;
                     case 'example':
-                        result = constraintExample();
+                        const constraintExampleContent = constraintExample();
+                        trackAndReturnHelp('constraint', 'example', JSON.stringify(constraintExampleContent));
+                        result = constraintExampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -466,10 +395,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'stats':
                 switch (params.action) {
                     case 'layer_summary':
-                        result = getLayerSummary();
+                        result = await getLayerSummary();
                         break;
                     case 'db_stats':
-                        result = getStats();
+                        result = await getStats();
                         break;
                     case 'clear':
                         result = clearOldData(params);
@@ -485,11 +414,63 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     case 'flush':
                         result = flushWAL();
                         break;
+                    case 'help_action':
+                        if (!params.target_tool || !params.target_action) {
+                            result = { error: 'Parameters "target_tool" and "target_action" are required' };
+                        }
+                        else {
+                            result = queryHelpAction(getAdapter(), params.target_tool, params.target_action);
+                        }
+                        break;
+                    case 'help_params':
+                        if (!params.target_tool || !params.target_action) {
+                            result = { error: 'Parameters "target_tool" and "target_action" are required' };
+                        }
+                        else {
+                            result = queryHelpParams(getAdapter(), params.target_tool, params.target_action);
+                        }
+                        break;
+                    case 'help_tool':
+                        if (!params.tool) {
+                            result = { error: 'Parameter "tool" is required' };
+                        }
+                        else {
+                            result = queryHelpTool(getAdapter(), params.tool);
+                        }
+                        break;
+                    case 'help_use_case':
+                        if (!params.use_case_id) {
+                            result = { error: 'Parameter "use_case_id" is required' };
+                        }
+                        else {
+                            result = queryHelpUseCase(getAdapter(), params.use_case_id);
+                        }
+                        break;
+                    case 'help_list_use_cases':
+                        result = queryHelpListUseCases(getAdapter(), {
+                            category: params.category,
+                            complexity: params.complexity,
+                            limit: params.limit,
+                            offset: params.offset
+                        });
+                        break;
+                    case 'help_next_actions':
+                        if (!params.target_tool || !params.target_action) {
+                            result = { error: 'Parameters "target_tool" and "target_action" are required' };
+                        }
+                        else {
+                            result = queryHelpNextActions(getAdapter(), params.target_tool, params.target_action);
+                        }
+                        break;
                     case 'help':
-                        result = statsHelp();
+                        const statsHelpContent = statsHelp();
+                        trackAndReturnHelp('stats', 'help', JSON.stringify(statsHelpContent));
+                        result = statsHelpContent;
                         break;
                     case 'example':
-                        result = statsExample();
+                        const statsExampleContent = statsExample();
+                        trackAndReturnHelp('stats', 'example', JSON.stringify(statsExampleContent));
+                        result = statsExampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -503,10 +484,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         result = updateConfig(params);
                         break;
                     case 'help':
-                        result = configHelp();
+                        const configHelpContent = configHelp();
+                        trackAndReturnHelp('config', 'help', JSON.stringify(configHelpContent));
+                        result = configHelpContent;
                         break;
                     case 'example':
-                        result = configExample();
+                        const configExampleContent = configExample();
+                        trackAndReturnHelp('config', 'example', JSON.stringify(configExampleContent));
+                        result = configExampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -514,46 +499,59 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'task':
                 switch (params.action) {
                     case 'create':
-                        result = createTask(params);
+                        result = await createTask(params);
                         break;
                     case 'update':
-                        result = updateTask(params);
+                        result = await updateTask(params);
                         break;
                     case 'get':
-                        result = getTask(params);
+                        result = await getTask(params);
                         break;
                     case 'list':
-                        result = listTasks(params);
+                        result = await listTasks(params);
                         break;
                     case 'move':
-                        result = moveTask(params);
+                        result = await moveTask(params);
                         break;
                     case 'link':
-                        result = linkTask(params);
+                        result = await linkTask(params);
                         break;
                     case 'archive':
-                        result = archiveTask(params);
+                        result = await archiveTask(params);
                         break;
                     case 'batch_create':
-                        result = batchCreateTasks({ tasks: params.tasks, atomic: params.atomic });
+                        result = await batchCreateTasks({ tasks: params.tasks, atomic: params.atomic });
                         break;
                     case 'add_dependency':
-                        result = addDependency(params);
+                        result = await addDependency(params);
                         break;
                     case 'remove_dependency':
-                        result = removeDependency(params);
+                        result = await removeDependency(params);
                         break;
                     case 'get_dependencies':
-                        result = getDependencies(params);
+                        result = await getDependencies(params);
+                        break;
+                    case 'watch_files':
+                        result = await watchFiles(params);
+                        break;
+                    case 'get_pruned_files':
+                        result = await getPrunedFiles(params);
+                        break;
+                    case 'link_pruned_file':
+                        result = await linkPrunedFile(params);
                         break;
                     case 'watcher':
-                        result = watcherStatus(params);
+                        result = await watcherStatus(params);
                         break;
                     case 'help':
-                        result = taskHelp();
+                        const taskHelpContent = taskHelp();
+                        trackAndReturnHelp('task', 'help', JSON.stringify(taskHelpContent));
+                        result = taskHelpContent;
                         break;
                     case 'example':
-                        result = taskExample();
+                        const taskExampleContent = taskExample();
+                        trackAndReturnHelp('task', 'example', JSON.stringify(taskExampleContent));
+                        result = taskExampleContent;
                         break;
                     default: throw new Error(`Unknown action: ${params.action}`);
                 }
@@ -561,12 +559,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
+        // Debug logging: Success
+        debugLogToolResponse(name, action, true, result);
         return {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        // Debug logging: Error
+        debugLogError(`Tool ${name}.${action}`, error);
+        debugLogToolResponse(name, action, false, undefined, { message });
         return {
             content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
             isError: true,
@@ -576,6 +579,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Handle graceful shutdown
 process.on('SIGINT', async () => {
     console.error('\n✓ Shutting down MCP server...');
+    debugLog('INFO', 'Received SIGINT, shutting down gracefully');
     try {
         const watcher = FileWatcher.getInstance();
         await watcher.stop();
@@ -584,10 +588,12 @@ process.on('SIGINT', async () => {
         // Ignore watcher errors during shutdown
     }
     closeDatabase();
+    closeDebugLogger();
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
     console.error('\n✓ Shutting down MCP server...');
+    debugLog('INFO', 'Received SIGTERM, shutting down gracefully');
     try {
         const watcher = FileWatcher.getInstance();
         await watcher.stop();
@@ -596,21 +602,63 @@ process.on('SIGTERM', async () => {
         // Ignore watcher errors during shutdown
     }
     closeDatabase();
+    closeDebugLogger();
     process.exit(0);
 });
 // Start server with stdio transport
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error('✓ MCP Shared Context Server running on stdio');
-    // Start file watcher for auto-task-tracking
     try {
-        const watcher = FileWatcher.getInstance();
-        await watcher.start();
+        // 0. Ensure .sqlew directory and config template exist (first launch)
+        ensureSqlewDirectory();
+        // 1. Initialize database
+        const config = dbPath ? { connection: { filename: dbPath } } : undefined;
+        db = await initializeDatabase(config);
+        // Apply CLI config overrides if provided
+        if (parsedArgs.autodeleteIgnoreWeekend !== undefined) {
+            await setConfigValue(db, CONFIG_KEYS.AUTODELETE_IGNORE_WEEKEND, parsedArgs.autodeleteIgnoreWeekend ? '1' : '0');
+        }
+        if (parsedArgs.autodeleteMessageHours !== undefined) {
+            await setConfigValue(db, CONFIG_KEYS.AUTODELETE_MESSAGE_HOURS, String(parsedArgs.autodeleteMessageHours));
+        }
+        if (parsedArgs.autodeleteFileHistoryDays !== undefined) {
+            await setConfigValue(db, CONFIG_KEYS.AUTODELETE_FILE_HISTORY_DAYS, String(parsedArgs.autodeleteFileHistoryDays));
+        }
+        // Display current config
+        const configValues = await getAllConfig(db);
+        const ignoreWeekend = configValues[CONFIG_KEYS.AUTODELETE_IGNORE_WEEKEND] === '1';
+        const messageHours = configValues[CONFIG_KEYS.AUTODELETE_MESSAGE_HOURS];
+        const fileHistoryDays = configValues[CONFIG_KEYS.AUTODELETE_FILE_HISTORY_DAYS];
+        console.error('✓ MCP Shared Context Server initialized');
+        if (dbPath) {
+            const source = parsedArgs.dbPath ? 'CLI' : 'config file';
+            console.error(`  Database: ${dbPath} (from ${source})`);
+        }
+        console.error(`  Auto-delete config: messages=${messageHours}h, file_history=${fileHistoryDays}d, ignore_weekend=${ignoreWeekend}`);
+        // Initialize debug logger (priority: CLI arg > environment variable > config file)
+        const debugLogPath = parsedArgs.debugLogPath || process.env.SQLEW_DEBUG || fileConfig.debug?.log_path;
+        initDebugLogger(debugLogPath);
+        debugLog('INFO', 'MCP Shared Context Server initialized', {
+            dbPath,
+            autoDeleteConfig: { messageHours, fileHistoryDays, ignoreWeekend }
+        });
+        // 2. Connect MCP server
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error('✓ MCP Shared Context Server running on stdio');
+        // 3. Start file watcher for auto-task-tracking (after database is ready)
+        try {
+            const watcher = FileWatcher.getInstance();
+            await watcher.start();
+        }
+        catch (error) {
+            console.error('⚠ Failed to start file watcher:', error);
+            console.error('  (Auto task tracking will be disabled)');
+        }
     }
     catch (error) {
-        console.error('⚠ Failed to start file watcher:', error);
-        console.error('  (Auto task tracking will be disabled)');
+        console.error('✗ Failed to initialize database:', error);
+        closeDatabase();
+        process.exit(1);
     }
 }
 main().catch((error) => {