@danielsimonjr/memory-mcp 0.48.0 → 9.8.0

package/dist/server/responseCompressor.d.ts

@@ -0,0 +1,94 @@
+/**
+ * MCP Response Compression Module
+ *
+ * Provides automatic compression for large MCP tool responses using brotli.
+ * Responses exceeding the threshold (default 256KB) are automatically
+ * compressed and base64-encoded for transport.
+ *
+ * @module server/responseCompressor
+ */
+/**
+ * Structure of a compressed MCP response.
+ * Clients receiving this format should check the `compressed` field
+ * and decompress the `data` field if true.
+ */
+export interface CompressedResponse {
+    /** Whether the response data is compressed */
+    compressed: boolean;
+    /** Compression format used */
+    compressionFormat: 'brotli' | 'none';
+    /** Encoding of the data field */
+    encoding: 'utf-8' | 'base64';
+    /** Original size in bytes (only present if compressed) */
+    originalSize?: number;
+    /** Compressed size in bytes (only present if compressed) */
+    compressedSize?: number;
+    /** The response data (compressed and base64-encoded, or plain text) */
+    data: string;
+}
+/**
+ * Options for response compression.
+ */
+export interface ResponseCompressionOptions {
+    /** Force compression regardless of size threshold */
+    forceCompress?: boolean;
+    /** Custom size threshold in bytes (default: 256KB from COMPRESSION_CONFIG) */
+    threshold?: number;
+    /** Brotli quality level 0-11 (default: 6 from COMPRESSION_CONFIG) */
+    quality?: number;
+}
+/**
+ * Conditionally compress a response based on size threshold.
+ *
+ * Responses smaller than the threshold are returned unchanged.
+ * Responses larger than the threshold are compressed with brotli
+ * and base64-encoded for safe JSON transport.
+ *
+ * @param content - The response content to potentially compress
+ * @param options - Compression options
+ * @returns A CompressedResponse object indicating compression status
+ *
+ * @example
+ * ```typescript
+ * // Auto-compress large response
+ * const response = await maybeCompressResponse(largeJsonString);
+ * if (response.compressed) {
+ *   console.log(`Compressed from ${response.originalSize} to ${response.compressedSize}`);
+ * }
+ *
+ * // Force compression
+ * const compressed = await maybeCompressResponse(data, { forceCompress: true });
+ * ```
+ */
+export declare function maybeCompressResponse(content: string, options?: ResponseCompressionOptions): Promise<CompressedResponse>;
+/**
+ * Decompress a compressed response back to its original string content.
+ *
+ * If the response is not compressed, returns the data unchanged.
+ *
+ * @param response - The CompressedResponse to decompress
+ * @returns The original string content
+ *
+ * @example
+ * ```typescript
+ * const original = await decompressResponse(compressedResponse);
+ * const parsed = JSON.parse(original);
+ * ```
+ */
+export declare function decompressResponse(response: CompressedResponse): Promise<string>;
+/**
+ * Check if a response object is a CompressedResponse.
+ *
+ * @param obj - The object to check
+ * @returns True if the object has the CompressedResponse structure
+ */
+export declare function isCompressedResponse(obj: unknown): obj is CompressedResponse;
+/**
+ * Calculate potential compression savings without actually compressing.
+ * Useful for estimating whether compression would be beneficial.
+ *
+ * @param content - The content to estimate compression for
+ * @returns Estimated compression ratio (0-1, lower is better compression)
+ */
+export declare function estimateCompressionRatio(content: string): number;
+//# sourceMappingURL=responseCompressor.d.ts.map

package/dist/server/responseCompressor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseCompressor.d.ts","sourceRoot":"","sources":["../../src/server/responseCompressor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,8BAA8B;IAC9B,iBAAiB,EAAE,QAAQ,GAAG,MAAM,CAAC;IACrC,iCAAiC;IACjC,QAAQ,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC7B,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,kBAAkB,CAAC,CA2B7B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAY5E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA8BhE"}

package/dist/server/responseCompressor.js

@@ -0,0 +1,127 @@
+/**
+ * MCP Response Compression Module
+ *
+ * Provides automatic compression for large MCP tool responses using brotli.
+ * Responses exceeding the threshold (default 256KB) are automatically
+ * compressed and base64-encoded for transport.
+ *
+ * @module server/responseCompressor
+ */
+import { compress, decompress } from '../utils/compressionUtil.js';
+import { COMPRESSION_CONFIG } from '../utils/constants.js';
+/**
+ * Conditionally compress a response based on size threshold.
+ *
+ * Responses smaller than the threshold are returned unchanged.
+ * Responses larger than the threshold are compressed with brotli
+ * and base64-encoded for safe JSON transport.
+ *
+ * @param content - The response content to potentially compress
+ * @param options - Compression options
+ * @returns A CompressedResponse object indicating compression status
+ *
+ * @example
+ * ```typescript
+ * // Auto-compress large response
+ * const response = await maybeCompressResponse(largeJsonString);
+ * if (response.compressed) {
+ *   console.log(`Compressed from ${response.originalSize} to ${response.compressedSize}`);
+ * }
+ *
+ * // Force compression
+ * const compressed = await maybeCompressResponse(data, { forceCompress: true });
+ * ```
+ */
+export async function maybeCompressResponse(content, options = {}) {
+    const threshold = options.threshold ?? COMPRESSION_CONFIG.AUTO_COMPRESS_RESPONSE_SIZE;
+    const originalSize = Buffer.byteLength(content, 'utf-8');
+    const shouldCompress = options.forceCompress || originalSize > threshold;
+    if (!shouldCompress) {
+        return {
+            compressed: false,
+            compressionFormat: 'none',
+            encoding: 'utf-8',
+            data: content,
+        };
+    }
+    const quality = options.quality ?? COMPRESSION_CONFIG.BROTLI_QUALITY_BATCH;
+    const result = await compress(content, { quality });
+    return {
+        compressed: true,
+        compressionFormat: 'brotli',
+        encoding: 'base64',
+        originalSize,
+        compressedSize: result.compressedSize,
+        data: result.compressed.toString('base64'),
+    };
+}
+/**
+ * Decompress a compressed response back to its original string content.
+ *
+ * If the response is not compressed, returns the data unchanged.
+ *
+ * @param response - The CompressedResponse to decompress
+ * @returns The original string content
+ *
+ * @example
+ * ```typescript
+ * const original = await decompressResponse(compressedResponse);
+ * const parsed = JSON.parse(original);
+ * ```
+ */
+export async function decompressResponse(response) {
+    if (!response.compressed) {
+        return response.data;
+    }
+    const buffer = Buffer.from(response.data, 'base64');
+    const decompressed = await decompress(buffer);
+    return decompressed.toString('utf-8');
+}
+/**
+ * Check if a response object is a CompressedResponse.
+ *
+ * @param obj - The object to check
+ * @returns True if the object has the CompressedResponse structure
+ */
+export function isCompressedResponse(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const response = obj;
+    return (typeof response.compressed === 'boolean' &&
+        (response.compressionFormat === 'brotli' || response.compressionFormat === 'none') &&
+        (response.encoding === 'utf-8' || response.encoding === 'base64') &&
+        typeof response.data === 'string');
+}
+/**
+ * Calculate potential compression savings without actually compressing.
+ * Useful for estimating whether compression would be beneficial.
+ *
+ * @param content - The content to estimate compression for
+ * @returns Estimated compression ratio (0-1, lower is better compression)
+ */
+export function estimateCompressionRatio(content) {
+    // Rough heuristic: JSON and repetitive text compress well (0.25-0.35)
+    // Random/binary data compresses poorly (0.9+)
+    const size = Buffer.byteLength(content, 'utf-8');
+    // Very small content has overhead that makes compression not worthwhile
+    if (size < 1000) {
+        return 1.0;
+    }
+    // Check for JSON-like content (compresses very well)
+    const jsonIndicators = (content.match(/[{}\[\]":,]/g) || []).length;
+    const jsonRatio = jsonIndicators / size;
+    if (jsonRatio > 0.1) {
+        // Highly JSON-like, expect 60-75% compression
+        return 0.25 + (0.1 * Math.random());
+    }
+    // Check for repetitive content
+    const uniqueChars = new Set(content).size;
+    const repetitionRatio = uniqueChars / Math.min(size, 256);
+    if (repetitionRatio < 0.3) {
+        // Very repetitive, expect 50-70% compression
+        return 0.3 + (0.15 * Math.random());
+    }
+    // Default estimate for mixed content
+    return 0.5 + (0.2 * Math.random());
+}

package/dist/server/toolDefinitions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MCP Tool Definitions
+ *
+ * Extracted from MCPServer.ts to reduce file size and improve maintainability.
+ * Contains all 47 tool schemas for the Knowledge Graph MCP Server.
+ *
+ * @module server/toolDefinitions
+ */
+/**
+ * Tool definition type matching MCP SDK expectations.
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+        additionalProperties?: boolean;
+    };
+}
+/**
+ * All tool definitions for the Knowledge Graph MCP Server.
+ * Organized by category for easier maintenance.
+ */
+export declare const toolDefinitions: ToolDefinition[];
+//# sourceMappingURL=toolDefinitions.d.ts.map

package/dist/server/toolDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolDefinitions.d.ts","sourceRoot":"","sources":["../../src/server/toolDefinitions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,EA03B3C,CAAC"}

package/dist/server/toolDefinitions.js

@@ -284,6 +284,20 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 10 Sprint 4: Automatic search method selection
+    {
+        name: 'search_auto',
+        description: 'Automatically select and execute the best search method based on query characteristics and graph size. Returns results along with the selected method and reasoning.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                limit: { type: 'number', description: 'Maximum results to return (default: 10)' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
     // ==================== SAVED SEARCH TOOLS ====================
     {
         name: 'save_search',
@@ -667,6 +681,95 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // ==================== GRAPH ALGORITHM TOOLS (Phase 4 Sprint 9) ====================
+    {
+        name: 'find_shortest_path',
+        description: 'Find the shortest path between two entities in the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: { type: 'string', description: 'Source entity name' },
+                target: { type: 'string', description: 'Target entity name' },
+                direction: {
+                    type: 'string',
+                    enum: ['outgoing', 'incoming', 'both'],
+                    description: 'Direction of traversal (default: both)',
+                },
+                relationTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional filter for relation types to follow',
+                },
+            },
+            required: ['source', 'target'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'find_all_paths',
+        description: 'Find all paths between two entities up to a maximum depth',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: { type: 'string', description: 'Source entity name' },
+                target: { type: 'string', description: 'Target entity name' },
+                maxDepth: { type: 'number', description: 'Maximum path length (default: 5)' },
+                direction: {
+                    type: 'string',
+                    enum: ['outgoing', 'incoming', 'both'],
+                    description: 'Direction of traversal (default: both)',
+                },
+                relationTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional filter for relation types to follow',
+                },
+            },
+            required: ['source', 'target'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_connected_components',
+        description: 'Find all connected components in the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_centrality',
+        description: 'Calculate centrality metrics for entities in the graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                algorithm: {
+                    type: 'string',
+                    enum: ['degree', 'betweenness', 'pagerank'],
+                    description: 'Centrality algorithm to use (default: degree)',
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['in', 'out', 'both'],
+                    description: 'Direction for degree centrality (default: both)',
+                },
+                topN: { type: 'number', description: 'Number of top entities to return (default: 10)' },
+                dampingFactor: { type: 'number', description: 'Damping factor for PageRank (default: 0.85)' },
+                approximate: {
+                    type: 'boolean',
+                    description: 'Use approximation for faster betweenness centrality (default: false)',
+                },
+                sampleRate: {
+                    type: 'number',
+                    description: 'Sample rate for approximation (0.0-1.0, default: 0.2)',
+                    minimum: 0.01,
+                    maximum: 1.0,
+                },
+            },
+            additionalProperties: false,
+        },
+    },
     // ==================== IMPORT/EXPORT TOOLS ====================
     {
         name: 'import_graph',
@@ -689,7 +792,7 @@ export const toolDefinitions = [
     },
     {
         name: 'export_graph',
-        description: 'Export knowledge graph in various formats',
+        description: 'Export knowledge graph in various formats with optional brotli compression and streaming for large graphs',
         inputSchema: {
             type: 'object',
             properties: {
@@ -708,25 +811,93 @@ export const toolDefinitions = [
                     },
                     description: 'Optional filter',
                 },
+                compress: {
+                    type: 'boolean',
+                    description: 'Compress output with brotli (auto-enabled for >100KB)',
+                    default: false,
+                },
+                compressionQuality: {
+                    type: 'number',
+                    description: 'Brotli quality level 0-11 (default: 6). Higher = better compression but slower.',
+                    minimum: 0,
+                    maximum: 11,
+                    default: 6,
+                },
+                streaming: {
+                    type: 'boolean',
+                    description: 'Use streaming mode to write directly to file (requires outputPath)',
+                    default: false,
+                },
+                outputPath: {
+                    type: 'string',
+                    description: 'File path for streaming export. Auto-enables streaming for graphs with >= 5000 entities.',
+                },
             },
             required: ['format'],
             additionalProperties: false,
         },
     },
+    // ==================== SEMANTIC SEARCH TOOLS (Phase 4 Sprint 12) ====================
+    {
+        name: 'semantic_search',
+        description: 'Search for entities using semantic similarity. Requires embedding provider to be configured via MEMORY_EMBEDDING_PROVIDER.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Natural language search query' },
+                limit: { type: 'number', description: 'Maximum number of results (default: 10, max: 100)' },
+                minSimilarity: {
+                    type: 'number',
+                    description: 'Minimum similarity score threshold (0.0-1.0, default: 0)',
+                },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'find_similar_entities',
+        description: 'Find entities similar to a given entity using semantic similarity. Requires embedding provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Name of entity to find similar entities for' },
+                limit: { type: 'number', description: 'Maximum number of results (default: 10, max: 100)' },
+                minSimilarity: {
+                    type: 'number',
+                    description: 'Minimum similarity score threshold (0.0-1.0, default: 0)',
+                },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'index_embeddings',
+        description: 'Index all entities for semantic search. Call this after adding entities to enable semantic search. Requires embedding provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                forceReindex: {
+                    type: 'boolean',
+                    description: 'Force re-indexing of all entities even if already indexed (default: false)',
+                },
+            },
+            additionalProperties: false,
+        },
+    },
 ];
-/**
- * Get tool definitions by category.
- */
-export const toolCategories = {
-    entity: ['create_entities', 'delete_entities', 'read_graph', 'open_nodes'],
-    relation: ['create_relations', 'delete_relations'],
-    observation: ['add_observations', 'delete_observations'],
-    search: ['search_nodes', 'search_by_date_range', 'search_nodes_ranked', 'boolean_search', 'fuzzy_search', 'get_search_suggestions'],
-    savedSearch: ['save_search', 'execute_saved_search', 'list_saved_searches', 'delete_saved_search', 'update_saved_search'],
-    tag: ['add_tags', 'remove_tags', 'set_importance', 'add_tags_to_multiple_entities', 'replace_tag', 'merge_tags'],
-    tagAlias: ['add_tag_alias', 'list_tag_aliases', 'remove_tag_alias', 'get_aliases_for_tag', 'resolve_tag'],
-    hierarchy: ['set_entity_parent', 'get_children', 'get_parent', 'get_ancestors', 'get_descendants', 'get_subtree', 'get_root_entities', 'get_entity_depth', 'move_entity'],
-    analytics: ['get_graph_stats', 'validate_graph'],
-    compression: ['find_duplicates', 'merge_entities', 'compress_graph', 'archive_entities'],
-    importExport: ['import_graph', 'export_graph'],
-};
+// Tool categories are documented in CLAUDE.md for reference:
+// - Entity Operations: create_entities, delete_entities, read_graph, open_nodes
+// - Relation Operations: create_relations, delete_relations
+// - Observation Management: add_observations, delete_observations
+// - Search: search_nodes, search_by_date_range, search_nodes_ranked, boolean_search, fuzzy_search, get_search_suggestions, search_auto
+// - Semantic Search: semantic_search, find_similar_entities, index_embeddings
+// - Saved Searches: save_search, execute_saved_search, list_saved_searches, delete_saved_search, update_saved_search
+// - Tag Management: add_tags, remove_tags, set_importance, add_tags_to_multiple_entities, replace_tag, merge_tags
+// - Tag Aliases: add_tag_alias, list_tag_aliases, remove_tag_alias, get_aliases_for_tag, resolve_tag
+// - Hierarchy: set_entity_parent, get_children, get_parent, get_ancestors, get_descendants, get_subtree, get_root_entities, get_entity_depth, move_entity
+// - Graph Algorithms: find_shortest_path, find_all_paths, get_connected_components, get_centrality
+// - Analytics: get_graph_stats, validate_graph
+// - Compression: find_duplicates, merge_entities, compress_graph, archive_entities
+// - Import/Export: import_graph, export_graph

package/dist/server/toolHandlers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MCP Tool Handlers
+ *
+ * Contains handler functions for all 51 Knowledge Graph tools.
+ * Handlers call managers directly via ManagerContext.
+ * Phase 4: Updated to use specialized managers for single responsibility.
+ * Phase 4 Sprint 9: Added 4 graph algorithm tools (find_shortest_path, find_all_paths, get_connected_components, get_centrality).
+ * Phase 6: Updated to use Zod validation instead of type assertions.
+ * Phase 3 Sprint 4: Added response compression for large payloads.
+ *
+ * @module server/toolHandlers
+ */
+import { formatToolResponse } from '../utils/index.js';
+import type { ManagerContext } from '../core/ManagerContext.js';
+/**
+ * Tool response type for MCP SDK compatibility.
+ */
+export type ToolResponse = ReturnType<typeof formatToolResponse>;
+/**
+ * Tool handler function signature.
+ */
+export type ToolHandler = (ctx: ManagerContext, args: Record<string, unknown>) => Promise<ToolResponse>;
+/**
+ * Registry of all tool handlers keyed by tool name.
+ * Handlers call managers directly for reduced abstraction layers.
+ *
+ * Note: Large-response tools (read_graph, search_nodes, get_subtree, open_nodes)
+ * are wrapped with automatic response compression for payloads >256KB.
+ */
+export declare const toolHandlers: Record<string, ToolHandler>;
+/**
+ * Handle a tool call by dispatching to the appropriate handler.
+ *
+ * @param name - Tool name to call
+ * @param args - Tool arguments
+ * @param ctx - Manager context with all manager instances
+ * @returns Tool response
+ * @throws Error if tool name is unknown
+ */
+export declare function handleToolCall(name: string, args: Record<string, unknown>, ctx: ManagerContext): Promise<ToolResponse>;
+//# sourceMappingURL=toolHandlers.d.ts.map

package/dist/server/toolHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolHandlers.d.ts","sourceRoot":"","sources":["../../src/server/toolHandlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,kBAAkB,EAkBnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAIhE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC,YAAY,CAAC,CAAC;AAyC3B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAqhBpD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,YAAY,CAAC,CAMvB"}