squish-memory 1.2.0 → 1.2.1

package/dist/core/mcp/server.js

@@ -1,157 +0,0 @@
-import express from 'express';
-import cors from 'cors';
-import rateLimit from 'express-rate-limit';
-import { logger } from '../logger.js';
-export class MCPServer {
-    app = express();
-    httpServer = null;
-    tools = new Map();
-    port;
-    serverName;
-    serverVersion;
-    constructor(port = 8767, serverName = 'squish-mcp', serverVersion = '0.9.0') {
-        this.port = port;
-        this.serverName = serverName;
-        this.serverVersion = serverVersion;
-        this.setupMiddleware();
-        this.setupRoutes();
-    }
-    setupMiddleware() {
-        const allowedOrigins = process.env.SQUISH_CORS_ORIGINS?.split(',').map(s => s.trim()) || ['http://localhost:*', 'http://127.0.0.1:*'];
-        const appCors = cors({
-            origin: (origin, callback) => {
-                if (!origin || allowedOrigins.some(allowed => {
-                    if (allowed.endsWith(':*')) {
-                        const prefix = allowed.slice(0, -1);
-                        return origin.startsWith(prefix);
-                    }
-                    return origin === allowed;
-                })) {
-                    callback(null, true);
-                }
-                else {
-                    callback(new Error('Not allowed by CORS'));
-                }
-            }
-        });
-        const limiter = rateLimit({
-            windowMs: 15 * 60 * 1000,
-            max: 100,
-            message: { error: 'Too many requests, please try again later.' },
-            standardHeaders: true,
-            legacyHeaders: false,
-        });
-        this.app.use(appCors);
-        this.app.use(limiter);
-        this.app.use(express.json());
-    }
-    setupRoutes() {
-        this.app.get('/sse', (req, res) => {
-            res.setHeader('Content-Type', 'text/event-stream');
-            res.setHeader('Cache-Control', 'no-cache');
-            res.setHeader('Connection', 'keep-alive');
-            res.flushHeaders();
-            res.write('data: {"type":"connected"}\n\n');
-            req.on('close', () => {
-                logger.info('SSE client disconnected');
-            });
-        });
-        this.app.post('/initialize', async (req, res) => {
-            try {
-                const request = req.body;
-                const response = {
-                    protocolVersion: '2024-11-05',
-                    capabilities: {
-                        tools: {
-                            listChanged: true,
-                        },
-                    },
-                    serverInfo: {
-                        name: this.serverName,
-                        version: this.serverVersion,
-                    },
-                };
-                res.json(response);
-            }
-            catch (error) {
-                logger.error('Initialize error:', error);
-                res.status(400).json({ error: 'Invalid initialize request' });
-            }
-        });
-        this.app.get('/tools/list', (req, res) => {
-            const tools = Array.from(this.tools.values()).map(def => def.tool);
-            res.json({ tools });
-        });
-        this.app.post('/tools/call', async (req, res) => {
-            try {
-                const { name, arguments: args } = req.body;
-                if (!name || typeof name !== 'string') {
-                    return res.status(400).json({ error: 'Tool name required' });
-                }
-                const toolDef = this.tools.get(name);
-                if (!toolDef) {
-                    return res.status(404).json({ error: `Tool not found: ${name}` });
-                }
-                const result = await toolDef.handler(args || {});
-                res.json(result);
-            }
-            catch (error) {
-                logger.error('Tool call error:', error);
-                res.status(500).json({
-                    error: error instanceof Error ? error.message : 'Tool execution failed'
-                });
-            }
-        });
-        this.app.get('/health', (req, res) => {
-            res.json({
-                status: 'ok',
-                server: this.serverName,
-                version: this.serverVersion,
-                tools: this.tools.size
-            });
-        });
-    }
-    registerTool(definition) {
-        this.tools.set(definition.tool.name, definition);
-        logger.info(`Registered MCP tool: ${definition.tool.name}`);
-    }
-    registerTools(definitions) {
-        definitions.forEach(def => this.registerTool(def));
-    }
-    async start() {
-        return new Promise((resolve, reject) => {
-            this.httpServer = this.app.listen(this.port, () => {
-                logger.info(`MCP server listening on port ${this.port}`);
-                logger.info(`SSE endpoint: http://localhost:${this.port}/sse`);
-                logger.info(`Tools available: ${this.tools.size}`);
-                resolve();
-            });
-            this.httpServer.on('error', (error) => {
-                logger.error('MCP server error:', error);
-                reject(error);
-            });
-        });
-    }
-    async stop() {
-        return new Promise((resolve, reject) => {
-            if (!this.httpServer) {
-                resolve();
-                return;
-            }
-            this.httpServer.close((error) => {
-                if (error) {
-                    logger.error('Error stopping MCP server:', error);
-                    reject(error);
-                }
-                else {
-                    logger.info('MCP server stopped');
-                    resolve();
-                }
-            });
-        });
-    }
-    getToolCount() {
-        return this.tools.size;
-    }
-}
-//# sourceMappingURL=server.js.map

package/dist/core/mcp/standalone-server.d.ts

@@ -1,13 +0,0 @@
-import { MCPServer } from './server.js';
-export declare class SquishMCPServer {
-    private server;
-    constructor();
-    initialize(): Promise<void>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getServer(): MCPServer;
-}
-export declare function getSquishMCPServer(): Promise<SquishMCPServer>;
-export declare function startMCPServer(): Promise<SquishMCPServer>;
-export declare function stopMCPServer(): Promise<void>;
-//# sourceMappingURL=standalone-server.d.ts.map

package/dist/core/mcp/standalone-server.js

@@ -1,46 +0,0 @@
-import { MCPServer } from './server.js';
-import { getAllSquishTools } from './tools.js';
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-export class SquishMCPServer {
-    server;
-    constructor() {
-        this.server = new MCPServer(config.mcpServerPort || 8767, 'squish-mcp', '0.9.0');
-    }
-    async initialize() {
-        const tools = getAllSquishTools();
-        this.server.registerTools(tools);
-        logger.info(`Squish MCP server initialized with ${tools.length} tools`);
-    }
-    async start() {
-        await this.server.start();
-        logger.info(`Squish MCP server started on port ${config.mcpServerPort || 8767}`);
-    }
-    async stop() {
-        await this.server.stop();
-        logger.info('Squish MCP server stopped');
-    }
-    getServer() {
-        return this.server;
-    }
-}
-let serverInstance = null;
-export async function getSquishMCPServer() {
-    if (!serverInstance) {
-        serverInstance = new SquishMCPServer();
-        await serverInstance.initialize();
-    }
-    return serverInstance;
-}
-export async function startMCPServer() {
-    const server = await getSquishMCPServer();
-    await server.start();
-    return server;
-}
-export async function stopMCPServer() {
-    if (serverInstance) {
-        await serverInstance.stop();
-        serverInstance = null;
-    }
-}
-//# sourceMappingURL=standalone-server.js.map

package/dist/core/mcp/tools.d.ts

@@ -1,7 +0,0 @@
-import { MCPToolDefinition } from './types.js';
-export declare const squishSearchTool: MCPToolDefinition;
-export declare const squishRememberTool: MCPToolDefinition;
-export declare const squishRecallTool: MCPToolDefinition;
-export declare const squishHealthTool: MCPToolDefinition;
-export declare function getAllSquishTools(): MCPToolDefinition[];
-//# sourceMappingURL=tools.d.ts.map

package/dist/core/mcp/tools.js

@@ -1,278 +0,0 @@
-import { hybridSearch } from '../memory/hybrid-retrieval.js';
-import { rememberMemory, getMemory } from '../memory/memories.js';
-import { getQMDClient } from '../embeddings/qmd-client.js';
-import { logger } from '../logger.js';
-function textResult(text) {
-    return {
-        content: [{ type: 'text', text }],
-    };
-}
-function errorResult(error) {
-    return {
-        content: [{ type: 'text', text: `Error: ${error}` }],
-        isError: true,
-    };
-}
-export const squishSearchTool = {
-    tool: {
-        name: 'squish_search',
-        description: 'Search Squish memory using hybrid scoring (semantic + recency + importance)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results to return (default: 5)',
-                },
-                project: {
-                    type: 'string',
-                    description: 'Project path filter',
-                },
-            },
-            required: ['query'],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { query, limit = 5, project } = args;
-            if (!query) {
-                return errorResult('Query is required');
-            }
-            const results = await hybridSearch({
-                query,
-                limit,
-                project,
-                candidateLimit: 50,
-                resultLimit: limit,
-            });
-            const formatted = results.map((r, i) => `${i + 1}. [${r.type || 'memory'}] ${r.content?.substring(0, 200)}... (score: ${r.hybridScore?.toFixed(2)})`).join('\n');
-            return textResult(`Found ${results.length} memories:\n\n${formatted}`);
-        }
-        catch (error) {
-            logger.error('Search error:', error);
-            return errorResult(error instanceof Error ? error.message : 'Search failed');
-        }
-    },
-};
-export const squishRememberTool = {
-    tool: {
-        name: 'squish_remember',
-        description: 'Store a new memory in Squish',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                content: {
-                    type: 'string',
-                    description: 'Memory content to store',
-                },
-                type: {
-                    type: 'string',
-                    description: 'Memory type (observation, fact, decision, context, preference)',
-                },
-                tags: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Optional tags',
-                },
-                project: {
-                    type: 'string',
-                    description: 'Project path',
-                },
-                // Rich context fields (Agent 4 feedback)
-                source: {
-                    type: 'string',
-                    description: 'Source of this memory (e.g., "voice", "chat", "document")',
-                },
-                reasoning: {
-                    type: 'string',
-                    description: 'Why this memory is important',
-                },
-                context: {
-                    type: 'string',
-                    description: 'What triggered this memory',
-                },
-                examples: {
-                    type: 'string',
-                    description: 'When to apply this knowledge',
-                },
-                exceptions: {
-                    type: 'string',
-                    description: 'When NOT to apply this',
-                },
-                tier: {
-                    type: 'string',
-                    description: 'Memory tier: hot (active) or cold (archived)',
-                    enum: ['hot', 'cold'],
-                },
-            },
-            required: ['content'],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { content, type = 'observation', tags = [], project, source, reasoning, context, examples, exceptions, tier = 'hot' } = args;
-            if (!content) {
-                return errorResult('Content is required');
-            }
-            const memory = await rememberMemory({
-                content,
-                type,
-                tags,
-                project,
-                source,
-                reasoning,
-                memoryContext: context,
-                examples,
-                exceptions,
-                tier,
-            });
-            return textResult(`Memory stored: ${memory.id}`);
-        }
-        catch (error) {
-            logger.error('Remember error:', error);
-            return errorResult(error instanceof Error ? error.message : 'Failed to store memory');
-        }
-    },
-};
-export const squishRecallTool = {
-    tool: {
-        name: 'squish_recall',
-        description: 'Retrieve a specific memory by ID',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                memoryId: {
-                    type: 'string',
-                    description: 'Memory ID to retrieve',
-                },
-            },
-            required: ['memoryId'],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { memoryId } = args;
-            if (!memoryId) {
-                return errorResult('Memory ID is required');
-            }
-            const memory = await getMemory(memoryId);
-            if (!memory) {
-                return errorResult('Memory not found');
-            }
-            return textResult(JSON.stringify(memory, null, 2));
-        }
-        catch (error) {
-            logger.error('Recall error:', error);
-            return errorResult(error instanceof Error ? error.message : 'Failed to retrieve memory');
-        }
-    },
-};
-export const squishHealthTool = {
-    tool: {
-        name: 'squish_health',
-        description: 'Check Squish health status',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    handler: async (args) => {
-        try {
-            const qmdClient = await getQMDClient();
-            const qmdAvailable = await qmdClient.isAvailable();
-            return textResult(JSON.stringify({
-                status: 'ok',
-                version: '0.9.0',
-                qmd: qmdAvailable ? 'available' : 'unavailable',
-                timestamp: new Date().toISOString(),
-            }, null, 2));
-        }
-        catch (error) {
-            return errorResult(error instanceof Error ? error.message : 'Health check failed');
-        }
-    },
-};
-const squishGetSearchTracesTool = {
-    tool: {
-        name: 'squish_get_search_traces',
-        description: 'Get recent search traces for debugging and performance analysis',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum traces to return (default: 10)',
-                },
-                sessionId: {
-                    type: 'string',
-                    description: 'Session ID filter',
-                },
-            },
-            required: [],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { limit = 10, sessionId } = args;
-            const collectorModule = await import('../tracing/collector.js');
-            const { getTraces } = collectorModule;
-            const traces = await getTraces({ limit, sessionId });
-            const formatted = traces.map((t, i) => `${i + 1}. [${t.id.substring(0, 8)}] Query: "${t.query.substring(0, 50)}" Duration: ${t.totalDurationMs}ms`).join('\n');
-            return textResult(`Found ${traces.length} traces:\n\n${formatted}`);
-        }
-        catch (error) {
-            logger.error('Get search traces error:', error);
-            return errorResult(error instanceof Error ? error.message : 'Get traces failed');
-        }
-    },
-};
-const squishGetTraceByIdTool = {
-    tool: {
-        name: 'squish_get_trace_by_id',
-        description: 'Get a specific search trace by ID with full stage details',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                traceId: {
-                    type: 'string',
-                    description: 'Trace ID to retrieve',
-                },
-            },
-            required: ['traceId'],
-        },
-    },
-    handler: async (args) => {
-        try {
-            const { traceId } = args;
-            const collectorModule = await import('../tracing/collector.js');
-            const { getTraceById } = collectorModule;
-            const visualizerModule = await import('../tracing/visualizer.js');
-            const { visualizeTrace } = visualizerModule;
-            const trace = await getTraceById(traceId);
-            if (!trace) {
-                return errorResult('Trace not found');
-            }
-            const visualization = visualizeTrace(trace);
-            return textResult(`\n${visualization}\n`);
-        }
-        catch (error) {
-            logger.error('Get trace by ID error:', error);
-            return errorResult(error instanceof Error ? error.message : 'Get trace by ID failed');
-        }
-    },
-};
-export function getAllSquishTools() {
-    return [
-        squishSearchTool,
-        squishRememberTool,
-        squishRecallTool,
-        squishHealthTool,
-        squishGetSearchTracesTool,
-        squishGetTraceByIdTool,
-    ];
-}
-//# sourceMappingURL=tools.js.map

package/dist/core/mcp/types.d.ts

@@ -1,87 +0,0 @@
-import { z } from 'zod';
-export declare const MCPToolSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, z.core.$strip>;
-export declare const MCPToolCallSchema: z.ZodObject<{
-    name: z.ZodString;
-    arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, z.core.$strip>;
-export declare const MCPToolResultSchema: z.ZodObject<{
-    content: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            text: "text";
-            image: "image";
-            resource: "resource";
-        }>;
-        text: z.ZodOptional<z.ZodString>;
-        data: z.ZodOptional<z.ZodString>;
-        mimeType: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    isError: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const MCPCapabilitiesSchema: z.ZodObject<{
-    tools: z.ZodOptional<z.ZodObject<{
-        listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    resources: z.ZodOptional<z.ZodObject<{
-        subscribe: z.ZodOptional<z.ZodBoolean>;
-        listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    prompts: z.ZodOptional<z.ZodObject<{
-        listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const MCPInitializeRequestSchema: z.ZodObject<{
-    protocolVersion: z.ZodString;
-    capabilities: z.ZodObject<{
-        tools: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        resources: z.ZodOptional<z.ZodObject<{
-            subscribe: z.ZodOptional<z.ZodBoolean>;
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        prompts: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    clientInfo: z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const MCPInitializeResponseSchema: z.ZodObject<{
-    protocolVersion: z.ZodString;
-    capabilities: z.ZodObject<{
-        tools: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        resources: z.ZodOptional<z.ZodObject<{
-            subscribe: z.ZodOptional<z.ZodBoolean>;
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        prompts: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    serverInfo: z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type MCPTool = z.infer<typeof MCPToolSchema>;
-export type MCPToolCall = z.infer<typeof MCPToolCallSchema>;
-export type MCPToolResult = z.infer<typeof MCPToolResultSchema>;
-export type MCPCapabilities = z.infer<typeof MCPCapabilitiesSchema>;
-export type MCPInitializeRequest = z.infer<typeof MCPInitializeRequestSchema>;
-export type MCPInitializeResponse = z.infer<typeof MCPInitializeResponseSchema>;
-export interface MCPToolHandler {
-    (args: Record<string, any>): Promise<MCPToolResult>;
-}
-export interface MCPToolDefinition {
-    tool: MCPTool;
-    handler: MCPToolHandler;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/core/mcp/types.js

@@ -1,48 +0,0 @@
-import { z } from 'zod';
-export const MCPToolSchema = z.object({
-    name: z.string(),
-    description: z.string(),
-    inputSchema: z.record(z.string(), z.any()),
-});
-export const MCPToolCallSchema = z.object({
-    name: z.string(),
-    arguments: z.record(z.string(), z.any()),
-});
-export const MCPToolResultSchema = z.object({
-    content: z.array(z.object({
-        type: z.enum(['text', 'image', 'resource']),
-        text: z.string().optional(),
-        data: z.string().optional(),
-        mimeType: z.string().optional(),
-    })),
-    isError: z.boolean().optional(),
-});
-export const MCPCapabilitiesSchema = z.object({
-    tools: z.object({
-        listChanged: z.boolean().optional(),
-    }).optional(),
-    resources: z.object({
-        subscribe: z.boolean().optional(),
-        listChanged: z.boolean().optional(),
-    }).optional(),
-    prompts: z.object({
-        listChanged: z.boolean().optional(),
-    }).optional(),
-});
-export const MCPInitializeRequestSchema = z.object({
-    protocolVersion: z.string(),
-    capabilities: MCPCapabilitiesSchema,
-    clientInfo: z.object({
-        name: z.string(),
-        version: z.string(),
-    }),
-});
-export const MCPInitializeResponseSchema = z.object({
-    protocolVersion: z.string(),
-    capabilities: MCPCapabilitiesSchema,
-    serverInfo: z.object({
-        name: z.string(),
-        version: z.string(),
-    }),
-});
-//# sourceMappingURL=types.js.map

package/dist/core/memory/bridge-discovery.d.ts

@@ -1,50 +0,0 @@
-/**
- * Bridge Discovery
- * Discovers indirect connections between memories through shared associations
- * Uses bidirectional BFS with Dijkstra-style weight prioritization
- * Finds "waypoint" memories that connect otherwise distant memory clusters
- */
-export interface BridgePath {
-    route: string[];
-    distance: number;
-    weight: number;
-    associationTypes: string[];
-}
-export interface BridgeMemory {
-    memoryId: string;
-    memory: any;
-    bridgeScore: number;
-    pathsThrough: number;
-    examplePaths: BridgePath[];
-    connectionDensity: number;
-    importance: 'critical' | 'major' | 'minor';
-}
-export interface BridgeOptions {
-    maxPathLength?: number;
-    topBridges?: number;
-    minPathWeight?: number;
-    includeExamplePaths?: boolean;
-}
-/**
- * Discover bridge memories connecting seed memory clusters
- */
-export declare function discoverBridges(seedMemoryIds: string[], projectId: string, options?: BridgeOptions): Promise<BridgeMemory[]>;
-/**
- * Get bridge memories for a single memory (find what it connects to)
- */
-export declare function getMemoryBridges(memoryId: string, projectId: string, topK?: number): Promise<BridgeMemory[]>;
-/**
- * Analyze overall network connectivity using bridge metrics
- */
-export declare function analyzeNetworkConnectivity(projectId: string, topBridges?: number): Promise<{
-    totalMemories: number;
-    totalConnections: number;
-    averageDegree: number;
-    bridgeMemories: BridgeMemory[];
-    networkDensity: number;
-    clustering: {
-        tightClusters: number;
-        looseClusters: number;
-    };
-}>;
-//# sourceMappingURL=bridge-discovery.d.ts.map