squish-memory 1.1.5 → 1.2.1

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

@@ -1,315 +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>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    inputSchema: Record<string, any>;
-}, {
-    name: string;
-    description: string;
-    inputSchema: Record<string, any>;
-}>;
-export declare const MCPToolCallSchema: z.ZodObject<{
-    name: z.ZodString;
-    arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    arguments: Record<string, any>;
-}, {
-    name: string;
-    arguments: Record<string, any>;
-}>;
-export declare const MCPToolResultSchema: z.ZodObject<{
-    content: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<["text", "image", "resource"]>;
-        text: z.ZodOptional<z.ZodString>;
-        data: z.ZodOptional<z.ZodString>;
-        mimeType: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }, {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }>, "many">;
-    isError: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    content: {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }[];
-    isError?: boolean | undefined;
-}, {
-    content: {
-        type: "text" | "image" | "resource";
-        text?: string | undefined;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    }[];
-    isError?: boolean | undefined;
-}>;
-export declare const MCPCapabilitiesSchema: z.ZodObject<{
-    tools: z.ZodOptional<z.ZodObject<{
-        listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        listChanged?: boolean | undefined;
-    }, {
-        listChanged?: boolean | undefined;
-    }>>;
-    resources: z.ZodOptional<z.ZodObject<{
-        subscribe: z.ZodOptional<z.ZodBoolean>;
-        listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    }, {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    }>>;
-    prompts: z.ZodOptional<z.ZodObject<{
-        listChanged: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        listChanged?: boolean | undefined;
-    }, {
-        listChanged?: boolean | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    tools?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    prompts?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    resources?: {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    } | undefined;
-}, {
-    tools?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    prompts?: {
-        listChanged?: boolean | undefined;
-    } | undefined;
-    resources?: {
-        listChanged?: boolean | undefined;
-        subscribe?: boolean | undefined;
-    } | undefined;
-}>;
-export declare const MCPInitializeRequestSchema: z.ZodObject<{
-    protocolVersion: z.ZodString;
-    capabilities: z.ZodObject<{
-        tools: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
-        resources: z.ZodOptional<z.ZodObject<{
-            subscribe: z.ZodOptional<z.ZodBoolean>;
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }>>;
-        prompts: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }>;
-    clientInfo: z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        version: string;
-        name: string;
-    }, {
-        version: string;
-        name: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    clientInfo: {
-        version: string;
-        name: string;
-    };
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-}, {
-    clientInfo: {
-        version: string;
-        name: string;
-    };
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-}>;
-export declare const MCPInitializeResponseSchema: z.ZodObject<{
-    protocolVersion: z.ZodString;
-    capabilities: z.ZodObject<{
-        tools: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
-        resources: z.ZodOptional<z.ZodObject<{
-            subscribe: z.ZodOptional<z.ZodBoolean>;
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        }>>;
-        prompts: z.ZodOptional<z.ZodObject<{
-            listChanged: z.ZodOptional<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            listChanged?: boolean | undefined;
-        }, {
-            listChanged?: boolean | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }, {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    }>;
-    serverInfo: z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        version: string;
-        name: string;
-    }, {
-        version: string;
-        name: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-    serverInfo: {
-        version: string;
-        name: string;
-    };
-}, {
-    capabilities: {
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            listChanged?: boolean | undefined;
-            subscribe?: boolean | undefined;
-        } | undefined;
-    };
-    protocolVersion: string;
-    serverInfo: {
-        version: string;
-        name: string;
-    };
-}>;
-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.any()),
-});
-export const MCPToolCallSchema = z.object({
-    name: z.string(),
-    arguments: z.record(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

package/dist/core/memory/bridge-discovery.js

@@ -1,291 +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
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { eq } from 'drizzle-orm';
-import { logger } from '../../core/logger.js';
-/**
- * Discover bridge memories connecting seed memory clusters
- */
-export async function discoverBridges(seedMemoryIds, projectId, options = {}) {
-    if (seedMemoryIds.length < 2) {
-        return [];
-    }
-    const maxPathLength = options.maxPathLength ?? 4;
-    const topBridges = options.topBridges ?? 10;
-    const minPathWeight = options.minPathWeight ?? 1;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Fetch all associations for this project
-        const allMemories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, projectId));
-        const memoriesById = new Map(allMemories.map((m) => [m.id, m]));
-        // Get all associations
-        const associations = await db.select().from(schema.memoryAssociations);
-        // Build adjacency list graph
-        const graph = new Map();
-        for (const assoc of associations) {
-            if (!graph.has(assoc.fromMemoryId)) {
-                graph.set(assoc.fromMemoryId, []);
-            }
-            const edges = graph.get(assoc.fromMemoryId);
-            if (edges) {
-                edges.push({
-                    toId: assoc.toMemoryId,
-                    weight: assoc.weight || 1,
-                    type: assoc.associationType,
-                });
-            }
-        }
-        // Find all paths between seed memories
-        const pathMetrics = new Map();
-        const allPaths = [];
-        for (let i = 0; i < seedMemoryIds.length; i++) {
-            for (let j = i + 1; j < seedMemoryIds.length; j++) {
-                const start = seedMemoryIds[i];
-                const end = seedMemoryIds[j];
-                const paths = findPaths(graph, start, end, maxPathLength, minPathWeight);
-                for (const path of paths) {
-                    // Record intermediate nodes (not start or end)
-                    for (let k = 1; k < path.route.length - 1; k++) {
-                        const nodeId = path.route[k];
-                        if (!pathMetrics.has(nodeId)) {
-                            pathMetrics.set(nodeId, { pathsThrough: 0, weight: 0 });
-                        }
-                        const metrics = pathMetrics.get(nodeId);
-                        metrics.pathsThrough++;
-                        metrics.weight += path.weight;
-                    }
-                    if (options.includeExamplePaths !== false) {
-                        allPaths.push(path);
-                    }
-                }
-            }
-        }
-        // Calculate bridge scores and convert to BridgeMemory objects
-        const bridges = [];
-        for (const [memoryId, metrics] of pathMetrics.entries()) {
-            const memory = memoriesById.get(memoryId);
-            if (!memory)
-                continue;
-            // Calculate betweenness centrality normalized to 0-100
-            const bridgeScore = Math.min(100, (metrics.pathsThrough / (seedMemoryIds.length * (seedMemoryIds.length - 1))) * 1000);
-            // Calculate connection density: how many unique memories it connects
-            const connectedMemories = new Set();
-            const neighbors = graph.get(memoryId) || [];
-            for (const neighbor of neighbors) {
-                connectedMemories.add(neighbor.toId);
-            }
-            // Include reverse connections
-            for (const [fromId, edges] of graph.entries()) {
-                for (const edge of edges) {
-                    if (edge.toId === memoryId && fromId !== memoryId) {
-                        connectedMemories.add(fromId);
-                    }
-                }
-            }
-            const connectionDensity = connectedMemories.size / Math.max(1, allMemories.length);
-            // Determine importance level
-            let importance;
-            if (bridgeScore >= 50) {
-                importance = 'critical';
-            }
-            else if (bridgeScore >= 20) {
-                importance = 'major';
-            }
-            else {
-                importance = 'minor';
-            }
-            // Get example paths through this bridge
-            const examplePaths = allPaths
-                .filter((p) => p.route.includes(memoryId) &&
-                p.route.length > 1)
-                .slice(0, 3);
-            bridges.push({
-                memoryId,
-                memory,
-                bridgeScore,
-                pathsThrough: metrics.pathsThrough,
-                examplePaths,
-                connectionDensity: Math.round(connectionDensity * 1000) / 1000,
-                importance,
-            });
-        }
-        // Sort by bridge score descending
-        bridges.sort((a, b) => b.bridgeScore - a.bridgeScore);
-        logger.debug('Bridges discovered', {
-            seedMemoryCount: seedMemoryIds.length,
-            bridgeCount: bridges.length,
-            topBridges: bridges.slice(0, topBridges).map((b) => ({
-                id: b.memoryId,
-                score: b.bridgeScore,
-                importance: b.importance,
-            })),
-        });
-        return bridges.slice(0, topBridges);
-    }
-    catch (error) {
-        logger.error('Error discovering bridges', error);
-        return [];
-    }
-}
-/**
- * Find all shortest paths between two memories up to maxLength
- * Uses BFS with weight-based distance metric
- */
-function findPaths(graph, start, end, maxLength, minWeight) {
-    const paths = [];
-    const queue = [{ current: start, route: [start], weight: 0, types: [] }];
-    const visited = new Set();
-    while (queue.length > 0) {
-        const { current, route, weight, types } = queue.shift();
-        // Stop if we've exceeded max path length
-        if (route.length > maxLength)
-            continue;
-        // Skip if already visited in shorter path
-        const routeKey = route.join('->');
-        if (visited.has(routeKey))
-            continue;
-        visited.add(routeKey);
-        // Check if we reached the destination
-        if (current === end && route.length > 1) {
-            paths.push({
-                route,
-                distance: route.length - 1,
-                weight,
-                associationTypes: types,
-            });
-            continue;
-        }
-        // Explore neighbors
-        const neighbors = graph.get(current) || [];
-        for (const neighbor of neighbors) {
-            // Skip if creating a cycle (except for final destination)
-            if (neighbor.toId !== end && route.includes(neighbor.toId))
-                continue;
-            // Skip if weight below threshold
-            if (neighbor.weight < minWeight)
-                continue;
-            queue.push({
-                current: neighbor.toId,
-                route: [...route, neighbor.toId],
-                weight: weight + neighbor.weight,
-                types: [...types, neighbor.type],
-            });
-        }
-    }
-    // Sort by weight (distance metric) and keep top paths
-    paths.sort((a, b) => b.weight - a.weight);
-    return paths.slice(0, 5); // Return top 5 paths
-}
-/**
- * Get bridge memories for a single memory (find what it connects to)
- */
-export async function getMemoryBridges(memoryId, projectId, topK = 5) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Find memories connected to this one
-        const associations = await db
-            .select()
-            .from(schema.memoryAssociations)
-            .where(eq(schema.memoryAssociations.fromMemoryId, memoryId));
-        if (associations.length === 0) {
-            return [];
-        }
-        // Get connected memory IDs
-        const connectedIds = new Set();
-        for (const assoc of associations) {
-            connectedIds.add(assoc.toMemoryId);
-        }
-        if (connectedIds.size < 2) {
-            return [];
-        }
-        // Discover bridges between connected memories
-        const seedIds = Array.from(connectedIds);
-        const bridges = await discoverBridges(seedIds, projectId, { topBridges: topK });
-        return bridges;
-    }
-    catch (error) {
-        logger.error('Error getting memory bridges', error);
-        return [];
-    }
-}
-/**
- * Analyze overall network connectivity using bridge metrics
- */
-export async function analyzeNetworkConnectivity(projectId, topBridges = 20) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get all memories
-        const allMemories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, projectId));
-        if (allMemories.length < 2) {
-            return {
-                totalMemories: allMemories.length,
-                totalConnections: 0,
-                averageDegree: 0,
-                bridgeMemories: [],
-                networkDensity: 0,
-                clustering: { tightClusters: 0, looseClusters: 0 },
-            };
-        }
-        // Get all associations
-        const associations = await db.select().from(schema.memoryAssociations);
-        // Calculate graph metrics
-        const degree = new Map();
-        for (const memory of allMemories) {
-            degree.set(memory.id, 0);
-        }
-        for (const assoc of associations) {
-            degree.set(assoc.fromMemoryId, (degree.get(assoc.fromMemoryId) || 0) + 1);
-        }
-        const avgDegree = Array.from(degree.values()).reduce((a, b) => a + b, 0) / allMemories.length;
-        const networkDensity = (associations.length * 2) / (allMemories.length * (allMemories.length - 1));
-        // Discover bridges for all memories
-        const seedIds = allMemories.slice(0, Math.min(10, allMemories.length)).map((m) => m.id);
-        const bridges = await discoverBridges(seedIds, projectId, { topBridges });
-        // Cluster analysis based on connectivity
-        let tightClusters = 0;
-        let looseClusters = 0;
-        for (const memory of allMemories) {
-            const connectionCount = degree.get(memory.id) || 0;
-            if (connectionCount > avgDegree * 1.5) {
-                tightClusters++;
-            }
-            else if (connectionCount < avgDegree * 0.5) {
-                looseClusters++;
-            }
-        }
-        return {
-            totalMemories: allMemories.length,
-            totalConnections: associations.length,
-            averageDegree: Math.round(avgDegree * 100) / 100,
-            bridgeMemories: bridges,
-            networkDensity: Math.round(networkDensity * 10000) / 10000,
-            clustering: { tightClusters, looseClusters },
-        };
-    }
-    catch (error) {
-        logger.error('Error analyzing network connectivity', error);
-        return {
-            totalMemories: 0,
-            totalConnections: 0,
-            averageDegree: 0,
-            bridgeMemories: [],
-            networkDensity: 0,
-            clustering: { tightClusters: 0, looseClusters: 0 },
-        };
-    }
-}
-//# sourceMappingURL=bridge-discovery.js.map