squish-memory 0.7.0

package/dist/index.js

@@ -0,0 +1,784 @@
+#!/usr/bin/env node
+/**
+ * Squish v0.6.0 - Major tool consolidation milestone
+ *
+ * This is a significant refactor reducing MCP tools from 18 to 11 (39% reduction).
+  * Breaking changes in tool API - migration guide: see docs/MIGRATION-v0.6.0.md
+ *
+ * Features:
+ * - 11 consolidated MCP tools (from 18)
+ * - Local mode: SQLite with FTS5 + auto-capture + folder context
+ * - Team mode: PostgreSQL + pgvector + Redis
+ * - Plugin system: Hooks for auto-capture, context injection, privacy filtering, folder context generation
+ * - Privacy-first: Secret detection, <private> tag filtering, async worker pipeline
+ * - Pluggable embeddings: OpenAI, Ollama, or local TF-IDF
+ *
+  * Consolidated MCP Tools (v0.6.0):
+ * - core_memory: Unified tool for view/edit/append operations (was 3 tools)
+ * - context_paging: Unified tool for load/evict/view operations (was 3 tools)
+ * - merge: Unified tool for detect/list/preview/stats/approve/reject/reverse (was 2 tools)
+ * - context_status, remember, recall, search, observe, context, health (unchanged)
+ * - lifecycle, summarize_session, protect_memory (unchanged)
+ *
+ * Plugin hooks (registered in plugin.json):
+ * - onInstall: Initialize database, create config files
+ * - onSessionStart: Inject relevant context + generate folder context
+ * - onUserPromptSubmit: Auto-capture user prompts with privacy filtering
+ * - onPostToolUse: Auto-capture tool executions and observe patterns
+ * - onSessionStop: Finalize observations, summarize via async worker
+ *
+ * See src/plugin/plugin-wrapper.ts for hook implementations
+  * See docs/MIGRATION-v0.6.0.md for migration guide
+ */
+import 'dotenv/config';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from './core/logger.js';
+import { checkDatabaseHealth, config } from './db/index.js';
+import { checkRedisHealth, closeCache } from './core/cache.js';
+import { rememberMemory, getMemoryById, searchMemories } from './core/memory/memories.js';
+import { searchConversations, getRecentConversations } from './core/search/conversations.js';
+import { createObservation } from './core/observations.js';
+import { getProjectContext } from './core/context.js';
+import { startWebServer } from './api/web/web.js';
+import { handleDetectDuplicates } from './algorithms/merge/handlers/detect-duplicates.js';
+import { handleListProposals } from './algorithms/merge/handlers/list-proposals.js';
+import { handlePreviewMerge } from './algorithms/merge/handlers/preview-merge.js';
+import { handleApproveMerge } from './algorithms/merge/handlers/approve-merge.js';
+import { handleRejectMerge } from './algorithms/merge/handlers/reject-merge.js';
+import { handleReverseMerge } from './algorithms/merge/handlers/reverse-merge.js';
+import { handleGetMergeStats } from './algorithms/merge/handlers/get-stats.js';
+import { forceLifecycleMaintenance } from './core/worker.js';
+import { summarizeSession } from './core/summarization.js';
+import { storeAgentMemory } from './core/agent-memory.js';
+import { getRelatedMemories } from './core/associations.js';
+import { protectMemory, pinMemory } from './core/governance.js';
+import { isDatabaseUnavailableError, determineOverallStatus } from './core/utils.js';
+import { searchWithQMD, isQMDAvailable } from './core/search/qmd-search.js';
+import { initializeCoreMemory, getCoreMemory, editCoreMemorySection, appendCoreMemorySection, getCoreMemoryStats, } from './core/core-memory.js';
+import { loadMemoryToContext, evictMemoryFromContext, viewLoadedMemories, getContextStatus, } from './core/context-paging.js';
+const VERSION = '0.6.0';
+const TOOLS = [
+    // ============================================================================
+    // Core Memory Tool (Tier 1 - Always-In-Context)
+    // ============================================================================
+    {
+        name: 'core_memory',
+        description: 'View or edit your core memory (always-visible). Use this to see your persona, user info, project context, and working notes. Update this when you learn something important that should always be visible.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['view', 'edit', 'append'],
+                    description: 'Memory action: view all, edit specific section, or append to section'
+                },
+                projectId: { type: 'string', description: 'Project ID' },
+                section: {
+                    type: 'string',
+                    enum: ['persona', 'user_info', 'project_context', 'working_notes'],
+                    description: 'Section name (required for edit/append actions)'
+                },
+                content: { type: 'string', description: 'New content for section (edit action)' },
+                text: { type: 'string', description: 'Text to append to section (append action)' },
+            },
+            required: ['action', 'projectId']
+        }
+    },
+    // ============================================================================
+    // Context Paging Tool (Tier 2 - Working Set Management)
+    // Note: Claude manages its own context/tokens. These track your working set.
+    // ============================================================================
+    {
+        name: 'context_paging',
+        description: 'Manage your working memory set. Load specific memories you want to keep visible, evict ones you no longer need, or view what is currently loaded.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['load', 'evict', 'view'],
+                    description: 'Paging action: load memory, evict memory, or view all loaded'
+                },
+                sessionId: { type: 'string', description: 'Session ID' },
+                memoryId: { type: 'string', description: 'Memory UUID (required for load/evict actions)' },
+            },
+            required: ['action', 'sessionId']
+        }
+    },
+    {
+        name: 'context_status',
+        description: 'View comprehensive context window status and token usage',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'Session ID' },
+                projectId: { type: 'string', description: 'Project ID' },
+            },
+            required: ['sessionId', 'projectId']
+        }
+    },
+    // ============================================================================
+    // Memory Tools (Original)
+    // ============================================================================
+    {
+        name: 'remember',
+        description: 'Store information for future use. Use this when you learn something important that you might need to recall later. Perfect for facts, decisions, code snippets, configuration details, or user preferences.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'Content to store' },
+                type: { type: 'string', enum: ['observation', 'fact', 'decision', 'context', 'preference'] },
+                tags: { type: 'array', items: { type: 'string' } },
+                project: { type: 'string', description: 'Project path' },
+                metadata: { type: 'object', description: 'Custom metadata' },
+                agentId: { type: 'string', description: 'Agent identifier (optional)' },
+                agentRole: { type: 'string', description: 'Agent role (optional)' },
+                visibilityScope: { type: 'string', enum: ['private', 'project', 'team', 'global'], description: 'Visibility scope for agent memories' },
+                sector: { type: 'string', enum: ['episodic', 'semantic', 'procedural', 'autobiographical', 'working'], description: 'Memory sector classification' }
+            },
+            required: ['content']
+        }
+    },
+    {
+        name: 'recall',
+        description: 'Retrieve a specific stored memory by ID (like reading a file). Use this when you have a memory ID and want to get its full content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory UUID' }
+            },
+            required: ['id']
+        }
+    },
+    {
+        name: 'search',
+        description: 'Search your stored memories for information (like grep). Use this when you need to find memories matching a query, or when the user asks about something you might have remembered. Leave query empty to list recent memories.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query (not required for scope=recent)' },
+                scope: {
+                    type: 'string',
+                    enum: ['memories', 'conversations', 'recent'],
+                    default: 'memories',
+                    description: 'Search scope: memories, conversations, or recent items'
+                },
+                type: { type: 'string', enum: ['observation', 'fact', 'decision', 'context', 'preference'] },
+                tags: { type: 'array', items: { type: 'string' } },
+                limit: { type: 'number', default: 10 },
+                project: { type: 'string' },
+                role: { type: 'string', enum: ['user', 'assistant'], description: 'Filter by role (conversations scope)' },
+                n: { type: 'number', description: 'Number of recent items (recent scope)' },
+                before: { type: 'string', description: 'ISO datetime for recent scope' },
+                after: { type: 'string', description: 'ISO datetime for recent scope' }
+            }
+        }
+    },
+    {
+        name: 'observe',
+        description: 'Record an observation about your work (tool usage, patterns, errors). Use this to document what you\'re learning about the codebase and problems you encounter.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['tool_use', 'file_change', 'error', 'pattern', 'insight'] },
+                action: { type: 'string', description: 'Action taken' },
+                target: { type: 'string', description: 'Target of action' },
+                summary: { type: 'string', description: 'Summary' },
+                details: { type: 'object' },
+                session: { type: 'string', description: 'Session ID' }
+            },
+            required: ['type', 'action', 'summary']
+        }
+    },
+    {
+        name: 'context',
+        description: 'Get project context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: 'Project path' },
+                include: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['memories', 'observations', 'entities', 'messages'] },
+                    default: ['memories', 'observations']
+                },
+                limit: { type: 'number', default: 10 }
+            },
+            required: ['project']
+        }
+    },
+    {
+        name: 'init',
+        description: 'Initialize Squish memory system for the current project. Creates the database structure and default settings. Run once when starting to use Squish in a new project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: {
+                    type: 'string',
+                    description: 'Project path (optional, defaults to current directory)'
+                }
+            }
+        }
+    },
+    {
+        name: 'health',
+        description: 'Check service status',
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'merge',
+        description: 'Manage memory merges: detect duplicates, list proposals, preview merges, get statistics, approve, reject, or reverse merges',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['detect', 'list', 'preview', 'stats', 'approve', 'reject', 'reverse'],
+                    description: 'Merge action: detect duplicates, list proposals, preview merge, view stats, approve, reject, or reverse'
+                },
+                projectId: { type: 'string', description: 'Project ID (required for detect, list, stats)' },
+                proposalId: { type: 'string', description: 'Proposal ID (required for preview, approve, reject)' },
+                mergeHistoryId: { type: 'string', description: 'Merge history ID (required for reverse action)' },
+                threshold: { type: 'number', description: 'Similarity threshold 0-1 (detect action only)' },
+                memoryType: { type: 'string', enum: ['fact', 'preference', 'decision', 'observation', 'context'], description: 'Memory type filter (detect action only)' },
+                status: { type: 'string', enum: ['pending', 'approved', 'rejected', 'expired'], description: 'Proposal status filter (list action only)' },
+                reviewNotes: { type: 'string', description: 'Notes or reason for decision (approve/reject only)' },
+                limit: { type: 'number', description: 'Max results to return' }
+            },
+            required: ['action']
+        }
+    },
+    {
+        name: 'lifecycle',
+        description: 'Run memory lifecycle maintenance (decay, eviction, tier updates)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: 'Project path (optional)' },
+                force: { type: 'boolean', description: 'Force immediate execution' }
+            }
+        }
+    },
+    {
+        name: 'summarize_session',
+        description: 'Summarize a conversation session',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                conversationId: { type: 'string', description: 'Conversation UUID' },
+                type: { type: 'string', enum: ['incremental', 'rolling', 'final'], description: 'Summary type' }
+            },
+            required: ['conversationId', 'type']
+        }
+    },
+    {
+        name: 'protect_memory',
+        description: 'Mark memory as protected (cannot be evicted)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'Memory UUID' },
+                reason: { type: 'string', description: 'Protection reason' }
+            },
+            required: ['memoryId', 'reason']
+        }
+    },
+    {
+        name: 'pin_memory',
+        description: 'Pin memory for automatic injection into context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'Memory UUID' }
+            },
+            required: ['memoryId']
+        }
+    },
+    {
+        name: 'get_related',
+        description: 'Find memories related to a specific memory by ID. Use this for iterative search - if a search result is relevant, find similar memories without needing new queries.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', description: 'Memory UUID' },
+                limit: { type: 'number', description: 'Max results (default: 10)' }
+            },
+            required: ['memoryId']
+        }
+    },
+    // ============================================================================
+    // QMD Hybrid Search Tool (v0.7.0)
+    // ============================================================================
+    {
+        name: 'qmd_search',
+        description: 'Search memories using QMD hybrid search (BM25 + vector + rerank). Provides higher quality results when QMD is available. Falls back to standard search if QMD is not installed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                type: { type: 'string', enum: ['observation', 'fact', 'decision', 'context', 'preference'], description: 'Memory type filter' },
+                limit: { type: 'number', description: 'Max results (default: 10)', default: 10 },
+                useHybrid: { type: 'boolean', description: 'Use full hybrid pipeline with reranking (default: true)', default: true },
+                collection: { type: 'string', description: 'Override default collection mapping' }
+            },
+            required: ['query']
+        }
+    }
+];
+class Squish {
+    server;
+    constructor() {
+        this.server = new Server({ name: 'squish', version: VERSION }, { capabilities: { tools: {} } });
+        this.setup();
+    }
+    setup() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: TOOLS
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (req) => {
+            const { name } = req.params;
+            const args = (req.params.arguments ?? {});
+            try {
+                switch (name) {
+                    case 'core_memory':
+                        return await this.handleCoreMemory(args);
+                    case 'context_paging':
+                        return await this.handleContextPaging(args);
+                    case 'context_status': {
+                        if (!args.sessionId || !args.projectId) {
+                            throw new McpError(ErrorCode.InvalidParams, 'sessionId and projectId are required');
+                        }
+                        try {
+                            const result = await getContextStatus(String(args.sessionId), String(args.projectId));
+                            return this.jsonResponse({ ok: true, ...result });
+                        }
+                        catch (error) {
+                            throw new McpError(ErrorCode.InternalError, `Context status failed: ${error.message}`);
+                        }
+                    }
+                    // Original Memory Tools
+                    case 'remember': {
+                        if (typeof args.content !== 'string' || !args.content) {
+                            throw new McpError(ErrorCode.InvalidParams, 'content is required');
+                        }
+                        try {
+                            // Check if agent context is provided
+                            if (args.agentId) {
+                                const memoryId = await storeAgentMemory(args.content, {
+                                    agentId: args.agentId,
+                                    agentRole: args.agentRole,
+                                }, {
+                                    type: args.type,
+                                    visibilityScope: args.visibilityScope,
+                                    sector: args.sector,
+                                    tags: args.tags,
+                                    metadata: args.metadata,
+                                });
+                                return this.jsonResponse({ ok: true, memoryId, agentContext: true });
+                            }
+                            else {
+                                // Standard memory storage
+                                return this.jsonResponse({ ok: true, data: await rememberMemory(args) });
+                            }
+                        }
+                        catch (dbError) {
+                            if (isDatabaseUnavailableError(dbError)) {
+                                throw new McpError(ErrorCode.InternalError, 'Database unavailable - memory storage disabled');
+                            }
+                            throw dbError;
+                        }
+                    }
+                    case 'recall': {
+                        if (!args.id) {
+                            throw new McpError(ErrorCode.InvalidParams, 'id is required');
+                        }
+                        try {
+                            const memory = await getMemoryById(String(args.id));
+                            return this.jsonResponse({ ok: true, found: !!memory, data: memory });
+                        }
+                        catch (dbError) {
+                            if (isDatabaseUnavailableError(dbError)) {
+                                throw new McpError(ErrorCode.InternalError, 'Database unavailable - memory retrieval disabled');
+                            }
+                            throw dbError;
+                        }
+                    }
+                    case 'search': {
+                        const scope = args.scope || 'memories';
+                        try {
+                            if (scope === 'memories') {
+                                if (typeof args.query !== 'string' || !args.query) {
+                                    throw new McpError(ErrorCode.InvalidParams, 'query is required for memory search');
+                                }
+                                return this.jsonResponse({ ok: true, scope: 'memories', data: await searchMemories(args) });
+                            }
+                            else if (scope === 'conversations') {
+                                if (typeof args.query !== 'string' || !args.query) {
+                                    throw new McpError(ErrorCode.InvalidParams, 'query is required for conversation search');
+                                }
+                                return this.jsonResponse({ ok: true, scope: 'conversations', data: await searchConversations(args) });
+                            }
+                            else if (scope === 'recent') {
+                                return this.jsonResponse({ ok: true, scope: 'recent', data: await getRecentConversations(args) });
+                            }
+                            else {
+                                throw new McpError(ErrorCode.InvalidParams, `Unknown scope: ${scope}`);
+                            }
+                        }
+                        catch (dbError) {
+                            if (isDatabaseUnavailableError(dbError)) {
+                                throw new McpError(ErrorCode.InternalError, 'Database unavailable - search disabled');
+                            }
+                            throw dbError;
+                        }
+                    }
+                    case 'observe': {
+                        if (!args.type || !args.action || !args.summary) {
+                            throw new McpError(ErrorCode.InvalidParams, 'type, action, and summary are required');
+                        }
+                        try {
+                            return this.jsonResponse({ ok: true, data: await createObservation(args) });
+                        }
+                        catch (dbError) {
+                            if (isDatabaseUnavailableError(dbError)) {
+                                throw new McpError(ErrorCode.InternalError, 'Database unavailable - observation storage disabled');
+                            }
+                            throw dbError;
+                        }
+                    }
+                    case 'context': {
+                        if (!args.project) {
+                            throw new McpError(ErrorCode.InvalidParams, 'project is required');
+                        }
+                        try {
+                            return this.jsonResponse({ ok: true, data: await getProjectContext(args) });
+                        }
+                        catch (dbError) {
+                            if (isDatabaseUnavailableError(dbError)) {
+                                throw new McpError(ErrorCode.InternalError, 'Database unavailable - context retrieval disabled');
+                            }
+                            throw dbError;
+                        }
+                    }
+                    case 'init': {
+                        const { projectPath } = args;
+                        const targetPath = projectPath || process.cwd();
+                        const { ensureProject } = await import('./core/projects.js');
+                        const { ensureDataDirectory } = await import('./db/bootstrap.js');
+                        const path = await import('path');
+                        try {
+                            // Ensure data directory exists
+                            await ensureDataDirectory();
+                            // Ensure project exists
+                            const project = await ensureProject(targetPath);
+                            if (!project) {
+                                return this.jsonResponse({
+                                    success: false,
+                                    error: 'Failed to create project',
+                                });
+                            }
+                            return this.jsonResponse({
+                                success: true,
+                                message: `Squish initialized for project: ${project.name}`,
+                                project: {
+                                    id: project.id,
+                                    name: project.name,
+                                    path: project.path,
+                                },
+                                nextSteps: [
+                                    'Squish is now ready to capture and store memories',
+                                    'Use /squish:remember to store important information',
+                                    'Use /squish:search to find stored memories',
+                                    'Use /squish:core_memory to view/edit your always-visible context',
+                                ],
+                            });
+                        }
+                        catch (error) {
+                            return this.jsonResponse({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                    case 'health':
+                        return this.health();
+                    case 'merge':
+                        return await this.handleMerge(args);
+                    case 'lifecycle': {
+                        const { project } = args;
+                        const result = await forceLifecycleMaintenance(project);
+                        return this.jsonResponse({
+                            success: true,
+                            message: 'Lifecycle maintenance completed',
+                            stats: result,
+                        });
+                    }
+                    case 'summarize_session': {
+                        const { conversationId, type } = args;
+                        if (!conversationId || !type) {
+                            throw new McpError(ErrorCode.InvalidParams, 'conversationId and type are required');
+                        }
+                        const result = await summarizeSession(conversationId, type);
+                        return this.jsonResponse({
+                            success: true,
+                            summaryId: result.summaryId,
+                            tokensSaved: result.tokensSaved,
+                            message: `Session summarized with type: ${type}`,
+                        });
+                    }
+                    case 'protect_memory': {
+                        const { memoryId, reason } = args;
+                        if (!memoryId || !reason) {
+                            throw new McpError(ErrorCode.InvalidParams, 'memoryId and reason are required');
+                        }
+                        await protectMemory(memoryId, reason);
+                        return this.jsonResponse({
+                            success: true,
+                            memoryId,
+                            message: 'Memory protected from eviction',
+                        });
+                    }
+                    case 'pin_memory': {
+                        const { memoryId } = args;
+                        if (!memoryId) {
+                            throw new McpError(ErrorCode.InvalidParams, 'memoryId is required');
+                        }
+                        await pinMemory(memoryId);
+                        return this.jsonResponse({
+                            success: true,
+                            memoryId,
+                            message: 'Memory pinned for auto-injection',
+                        });
+                    }
+                    case 'get_related': {
+                        const { memoryId, limit } = args;
+                        if (!memoryId) {
+                            throw new McpError(ErrorCode.InvalidParams, 'memoryId is required');
+                        }
+                        const related = await getRelatedMemories(memoryId, limit || 10);
+                        return this.jsonResponse({
+                            success: true,
+                            memoryId,
+                            relatedCount: related.length,
+                            memories: related,
+                        });
+                    }
+                    case 'qmd_search': {
+                        if (typeof args.query !== 'string' || !args.query) {
+                            throw new McpError(ErrorCode.InvalidParams, 'query is required');
+                        }
+                        try {
+                            const available = await isQMDAvailable();
+                            if (!available) {
+                                return this.jsonResponse({
+                                    ok: true,
+                                    qmdAvailable: false,
+                                    message: 'QMD is not installed. Install with: bun install -g qmd',
+                                    fallback: 'Using standard Squish search',
+                                    data: await searchMemories(args)
+                                });
+                            }
+                            const results = await searchWithQMD({
+                                query: args.query,
+                                type: args.type,
+                                limit: args.limit || 10,
+                                useHybrid: args.useHybrid ?? true,
+                                collection: args.collection
+                            });
+                            return this.jsonResponse({
+                                ok: true,
+                                qmdAvailable: true,
+                                data: results
+                            });
+                        }
+                        catch (dbError) {
+                            if (isDatabaseUnavailableError(dbError)) {
+                                throw new McpError(ErrorCode.InternalError, 'Database unavailable - search disabled');
+                            }
+                            throw dbError;
+                        }
+                    }
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof McpError)
+                    throw error;
+                logger.error('Tool error', error);
+                throw new McpError(ErrorCode.InternalError, `Tool '${name}' failed`);
+            }
+        });
+        this.server.onerror = (e) => logger.error('MCP Server error', e);
+        process.on('SIGINT', () => this.shutdown());
+        process.on('SIGTERM', () => this.shutdown());
+    }
+    jsonResponse(payload) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(payload, null, 2)
+                }]
+        };
+    }
+    async handleCoreMemory(args) {
+        const action = args.action;
+        if (!args.projectId) {
+            throw new McpError(ErrorCode.InvalidParams, 'projectId is required');
+        }
+        const projectId = String(args.projectId);
+        try {
+            await initializeCoreMemory(projectId);
+            if (action === 'view') {
+                const content = await getCoreMemory(projectId);
+                const stats = await getCoreMemoryStats(projectId);
+                return this.jsonResponse({ ok: true, action: 'view', content, stats });
+            }
+            if (action === 'edit') {
+                if (!args.section || typeof args.content !== 'string') {
+                    throw new McpError(ErrorCode.InvalidParams, 'section and content are required for edit action');
+                }
+                const result = await editCoreMemorySection(projectId, args.section, String(args.content));
+                if (!result.success) {
+                    throw new McpError(ErrorCode.InvalidParams, result.message || 'Edit failed');
+                }
+                return this.jsonResponse({ ok: true, action: 'edit', ...result });
+            }
+            if (action === 'append') {
+                if (!args.section || typeof args.text !== 'string') {
+                    throw new McpError(ErrorCode.InvalidParams, 'section and text are required for append action');
+                }
+                const result = await appendCoreMemorySection(projectId, args.section, String(args.text));
+                if (!result.success) {
+                    throw new McpError(ErrorCode.InvalidParams, result.message || 'Append failed');
+                }
+                return this.jsonResponse({ ok: true, action: 'append', ...result });
+            }
+            throw new McpError(ErrorCode.InvalidParams, `Unknown core_memory action: ${action}`);
+        }
+        catch (error) {
+            if (error instanceof McpError)
+                throw error;
+            throw new McpError(ErrorCode.InternalError, `Core memory failed: ${error.message}`);
+        }
+    }
+    async handleContextPaging(args) {
+        const action = args.action;
+        if (!args.sessionId) {
+            throw new McpError(ErrorCode.InvalidParams, 'sessionId is required');
+        }
+        const sessionId = String(args.sessionId);
+        try {
+            if (action === 'load') {
+                if (!args.memoryId) {
+                    throw new McpError(ErrorCode.InvalidParams, 'memoryId is required for load action');
+                }
+                const result = await loadMemoryToContext(sessionId, String(args.memoryId));
+                if (!result.success) {
+                    throw new McpError(ErrorCode.InvalidParams, result.message || 'Load failed');
+                }
+                return this.jsonResponse({ ok: true, action: 'load', ...result });
+            }
+            if (action === 'evict') {
+                if (!args.memoryId) {
+                    throw new McpError(ErrorCode.InvalidParams, 'memoryId is required for evict action');
+                }
+                const result = await evictMemoryFromContext(sessionId, String(args.memoryId));
+                if (!result.success) {
+                    throw new McpError(ErrorCode.InvalidParams, result.message || 'Evict failed');
+                }
+                return this.jsonResponse({ ok: true, action: 'evict', ...result });
+            }
+            if (action === 'view') {
+                const result = await viewLoadedMemories(sessionId);
+                return this.jsonResponse({ ok: true, action: 'view', ...result });
+            }
+            throw new McpError(ErrorCode.InvalidParams, `Unknown context_paging action: ${action}`);
+        }
+        catch (error) {
+            if (error instanceof McpError)
+                throw error;
+            throw new McpError(ErrorCode.InternalError, `Context paging failed: ${error.message}`);
+        }
+    }
+    async handleMerge(args) {
+        const action = args.action;
+        try {
+            if (action === 'detect') {
+                return this.jsonResponse(await handleDetectDuplicates(args));
+            }
+            if (action === 'list') {
+                return this.jsonResponse(await handleListProposals(args));
+            }
+            if (action === 'preview') {
+                return this.jsonResponse(await handlePreviewMerge(args));
+            }
+            if (action === 'stats') {
+                return this.jsonResponse(await handleGetMergeStats(args));
+            }
+            if (action === 'approve') {
+                return this.jsonResponse(await handleApproveMerge(args));
+            }
+            if (action === 'reject') {
+                return this.jsonResponse(await handleRejectMerge(args));
+            }
+            if (action === 'reverse') {
+                return this.jsonResponse(await handleReverseMerge(args));
+            }
+            throw new McpError(ErrorCode.InvalidParams, `Unknown merge action: ${action}`);
+        }
+        catch (error) {
+            if (error instanceof McpError)
+                throw error;
+            throw new McpError(ErrorCode.InternalError, `Merge operation failed: ${error.message}`);
+        }
+    }
+    async shutdown() {
+        await closeCache();
+        process.exit(0);
+    }
+    async health() {
+        let dbOk = false;
+        let dbStatus = 'ok';
+        try {
+            dbOk = await checkDatabaseHealth();
+            dbStatus = dbOk ? 'ok' : 'unavailable';
+        }
+        catch (error) {
+            if (isDatabaseUnavailableError(error)) {
+                dbStatus = 'unavailable';
+            }
+            else {
+                dbStatus = 'error';
+            }
+        }
+        const redisOk = await checkRedisHealth();
+        const overallStatus = determineOverallStatus(dbStatus, redisOk);
+        return this.jsonResponse({
+            version: VERSION,
+            mode: config.isTeamMode ? 'team' : 'local',
+            database: config.isTeamMode ? 'postgresql' : 'sqlite',
+            cache: config.redisEnabled ? 'redis' : 'memory',
+            embeddingsProvider: config.embeddingsProvider,
+            status: overallStatus,
+            checks: {
+                database: dbStatus,
+                cache: redisOk ? 'ok' : 'error'
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        logger.info(`v${VERSION}`);
+        // Start web UI server in background
+        startWebServer();
+    }
+}
+new Squish().run().catch((e) => {
+    logger.error('Fatal error', e);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map