ucm-mcp-server 6.6.0 → 6.7.0

package/dist/mcp-server/tools/memory-graph/GraphGetEntityTool.js

@@ -1,49 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphGetEntitySchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphGetEntityTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_get_entity'; }
-    get description() {
-        return 'Get full details of an entity including all properties, data, and provenance. Use the entityId from find_entities or explore results.';
-    }
-    get schema() { return GraphGetEntitySchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                memoryGraphId: {
-                    type: 'string',
-                    description: 'The Memory Graph ID'
-                },
-                entityId: {
-                    type: 'string',
-                    description: 'The entity ID or slug to retrieve'
-                },
-                detailLevel: {
-                    type: 'string',
-                    enum: ['brief', 'summary', 'full'],
-                    description: 'Detail level (default: full)'
-                }
-            },
-            required: ['memoryGraphId', 'entityId']
-        };
-    }
-    async handleExecute(params) {
-        const { memoryGraphId, entityId, detailLevel } = params;
-        this.logger.info('GraphGetEntityTool', `Getting entity ${entityId} from graph: ${memoryGraphId}`);
-        try {
-            const result = await this.ucmClient.graphGetEntity(memoryGraphId, entityId, detailLevel);
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            if (error.response?.status === 404) {
-                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
-            }
-            throw new McpError(McpErrorCode.InternalError, `Failed to get entity: ${error.message}`);
-        }
-    }
-}
-//# sourceMappingURL=GraphGetEntityTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphGetRelationshipsTool.d.ts

@@ -1,14 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
-import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphGetRelationshipsParams } from '@/schemas/memory-graph-tool-schemas.js';
-import { ZodSchema } from 'zod';
-export declare class GraphGetRelationshipsTool extends BaseToolController {
-    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
-    get name(): string;
-    get description(): string;
-    get schema(): ZodSchema;
-    get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: GraphGetRelationshipsParams): Promise<string>;
-}
-//# sourceMappingURL=GraphGetRelationshipsTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphGetRelationshipsTool.js

@@ -1,62 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphGetRelationshipsSchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphGetRelationshipsTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_get_relationships'; }
-    get description() {
-        return 'Get relationships for an entity with optional type filtering and direction control (outbound, inbound, or both).';
-    }
-    get schema() { return GraphGetRelationshipsSchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                memoryGraphId: {
-                    type: 'string',
-                    description: 'The Memory Graph ID'
-                },
-                entityId: {
-                    type: 'string',
-                    description: 'The entity ID to get relationships for'
-                },
-                relationshipTypes: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Filter by relationship types (from vocabulary)'
-                },
-                direction: {
-                    type: 'string',
-                    enum: ['outbound', 'inbound', 'both'],
-                    description: 'Relationship direction (default: both)'
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results (default: 50)'
-                }
-            },
-            required: ['memoryGraphId', 'entityId']
-        };
-    }
-    async handleExecute(params) {
-        const { memoryGraphId, entityId, relationshipTypes, direction, limit } = params;
-        this.logger.info('GraphGetRelationshipsTool', `Getting relationships for entity ${entityId}`);
-        try {
-            const result = await this.ucmClient.graphGetRelationships(memoryGraphId, entityId, {
-                direction,
-                relationshipTypes,
-                limit
-            });
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            if (error.response?.status === 404) {
-                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
-            }
-            throw new McpError(McpErrorCode.InternalError, `Failed to get relationships: ${error.message}`);
-        }
-    }
-}
-//# sourceMappingURL=GraphGetRelationshipsTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphListTemplatesTool.d.ts

@@ -1,14 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
-import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphListTemplatesParams } from '@/schemas/memory-graph-tool-schemas.js';
-import { ZodSchema } from 'zod';
-export declare class GraphListTemplatesTool extends BaseToolController {
-    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
-    get name(): string;
-    get description(): string;
-    get schema(): ZodSchema;
-    get inputSchema(): Record<string, unknown>;
-    protected handleExecute(_params: GraphListTemplatesParams): Promise<string>;
-}
-//# sourceMappingURL=GraphListTemplatesTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphListTemplatesTool.js

@@ -1,34 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphListTemplatesSchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphListTemplatesTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_list_templates'; }
-    get description() {
-        return 'List available vocabulary templates for creating Memory Graphs. Each template defines entity types, relationship types, and property definitions for a specific domain. Use the templateId when calling ucm_graph_create.';
-    }
-    get schema() { return GraphListTemplatesSchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {},
-            required: []
-        };
-    }
-    async handleExecute(_params) {
-        this.logger.info('GraphListTemplatesTool', 'Listing vocabulary templates');
-        try {
-            const result = await this.ucmClient.listMemoryGraphTemplates();
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            if (error.response?.status === 503) {
-                throw new McpError(McpErrorCode.InternalError, `Deep Memory service is not configured`);
-            }
-            throw new McpError(McpErrorCode.InternalError, `Failed to list templates: ${error.message}`);
-        }
-    }
-}
-//# sourceMappingURL=GraphListTemplatesTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphListTool.d.ts

@@ -1,14 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
-import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphListParams } from '@/schemas/memory-graph-tool-schemas.js';
-import { ZodSchema } from 'zod';
-export declare class GraphListTool extends BaseToolController {
-    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
-    get name(): string;
-    get description(): string;
-    get schema(): ZodSchema;
-    get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: GraphListParams): Promise<string>;
-}
-//# sourceMappingURL=GraphListTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphListTool.js

@@ -1,45 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { GraphListSchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphListTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_list'; }
-    get description() {
-        return 'List all Memory Graphs you have access to (including those not in a Knowledge Set). Returns graph metadata, embedding status, descriptions, and ownership scope (personal or organization).';
-    }
-    get schema() { return GraphListSchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                scope: {
-                    type: 'string',
-                    enum: ['organization', 'personal', 'all'],
-                    description: 'Filter graphs by ownership scope. "organization" returns only org graphs, "personal" returns only your personal graphs, "all" (default) returns both.'
-                }
-            },
-            required: []
-        };
-    }
-    async handleExecute(params) {
-        const { scope } = params;
-        this.logger.info('GraphListTool', `Listing memory graphs (scope: ${scope ?? 'all'})`);
-        const result = await this.ucmClient.listMemoryGraphs(scope ?? 'all');
-        // Annotate each graph with a scope field based on which owner field is set
-        if (result && Array.isArray(result.data)) {
-            result.data = result.data.map((graph) => ({
-                ...graph,
-                scope: graph.userId ? 'personal' : 'organization'
-            }));
-        }
-        else if (Array.isArray(result)) {
-            return JSON.stringify(result.map((graph) => ({
-                ...graph,
-                scope: graph.userId ? 'personal' : 'organization'
-            })));
-        }
-        return JSON.stringify(result);
-    }
-}
-//# sourceMappingURL=GraphListTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphOpenTool.d.ts

@@ -1,15 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
-import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphOpenParams } from '@/schemas/memory-graph-tool-schemas.js';
-import { ZodSchema } from 'zod';
-export declare class GraphOpenTool extends BaseToolController {
-    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
-    get name(): string;
-    get description(): string;
-    get schema(): ZodSchema;
-    get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: GraphOpenParams): Promise<string>;
-    private handleApiError;
-}
-//# sourceMappingURL=GraphOpenTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphOpenTool.js

@@ -1,50 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphOpenSchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphOpenTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_open'; }
-    get description() {
-        return 'Open a Memory Graph and get its vocabulary, statistics, instructions, and policies. Call this FIRST before querying a graph — it returns the schema (entity types, relationship types, property definitions) needed to construct queries.';
-    }
-    get schema() { return GraphOpenSchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                memoryGraphId: {
-                    type: 'string',
-                    description: 'The Memory Graph ID to open'
-                }
-            },
-            required: ['memoryGraphId']
-        };
-    }
-    async handleExecute(params) {
-        const { memoryGraphId } = params;
-        this.logger.info('GraphOpenTool', `Opening graph: ${memoryGraphId}`);
-        try {
-            const result = await this.ucmClient.graphOpen(memoryGraphId);
-            // scope is now returned directly by the OpenGraphCommand — no annotation needed
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            this.handleApiError(error, 'open memory graph');
-        }
-    }
-    handleApiError(error, action) {
-        if (error.response?.status === 403) {
-            throw new McpError(McpErrorCode.InvalidParams, `Access denied: you do not have permission to open this Memory Graph`);
-        }
-        if (error.response?.status === 404) {
-            throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
-        }
-        if (error.response?.status === 503) {
-            throw new McpError(McpErrorCode.InternalError, `Deep Memory service is not configured`);
-        }
-        throw new McpError(McpErrorCode.InternalError, `Failed to ${action}: ${error.message}`);
-    }
-}
-//# sourceMappingURL=GraphOpenTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphProposeVocabularyTool.d.ts

@@ -1,14 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
-import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphProposeVocabularyParams } from '@/schemas/memory-graph-tool-schemas.js';
-import { ZodSchema } from 'zod';
-export declare class GraphProposeVocabularyTool extends BaseToolController {
-    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
-    get name(): string;
-    get description(): string;
-    get schema(): ZodSchema;
-    get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: GraphProposeVocabularyParams): Promise<string>;
-}
-//# sourceMappingURL=GraphProposeVocabularyTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphProposeVocabularyTool.js

@@ -1,108 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphProposeVocabularySchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphProposeVocabularyTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_propose_vocabulary'; }
-    get description() {
-        return 'Propose new entity types or relationship types for a Memory Graph vocabulary. Behaviour depends on the governance mode: auto-approved in "open" mode, queued for review in "managed" mode, rejected in "locked" mode.';
-    }
-    get schema() { return GraphProposeVocabularySchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                memoryGraphId: {
-                    type: 'string',
-                    description: 'The Memory Graph ID'
-                },
-                entityTypes: {
-                    type: 'array',
-                    description: 'New entity types to propose',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            type: { type: 'string', description: 'Entity type name (PascalCase)' },
-                            description: { type: 'string', description: 'Description of the entity type' },
-                            justification: { type: 'string', description: 'Why this entity type is needed' },
-                            properties: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        name: { type: 'string', description: 'Property name' },
-                                        type: { type: 'string', description: 'Property type: string, number, boolean, date, enum' },
-                                        required: { type: 'boolean', description: 'Whether the property is required' },
-                                        description: { type: 'string', description: 'Property description' }
-                                    },
-                                    required: ['name', 'type', 'required']
-                                },
-                                description: 'Property schemas for the entity type'
-                            }
-                        },
-                        required: ['type', 'description', 'justification']
-                    }
-                },
-                relationshipTypes: {
-                    type: 'array',
-                    description: 'New relationship types to propose',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            type: { type: 'string', description: 'Relationship type name (SCREAMING_SNAKE_CASE)' },
-                            description: { type: 'string', description: 'Description of the relationship type' },
-                            justification: { type: 'string', description: 'Why this relationship type is needed' },
-                            allowedSourceTypes: { type: 'array', items: { type: 'string' }, description: 'Allowed source entity types' },
-                            allowedTargetTypes: { type: 'array', items: { type: 'string' }, description: 'Allowed target entity types' },
-                            bidirectional: { type: 'boolean', description: 'Whether the relationship is symmetric (default: false)' },
-                            properties: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        name: { type: 'string', description: 'Property name' },
-                                        type: { type: 'string', description: 'Property type: string, number, boolean, date, enum' },
-                                        required: { type: 'boolean', description: 'Whether the property is required' },
-                                        description: { type: 'string', description: 'Property description' }
-                                    },
-                                    required: ['name', 'type', 'required']
-                                },
-                                description: 'Property schemas for the relationship type'
-                            }
-                        },
-                        required: ['type', 'description', 'justification', 'allowedSourceTypes', 'allowedTargetTypes']
-                    }
-                }
-            },
-            required: ['memoryGraphId']
-        };
-    }
-    async handleExecute(params) {
-        const { memoryGraphId, entityTypes, relationshipTypes } = params;
-        if ((!entityTypes || entityTypes.length === 0) && (!relationshipTypes || relationshipTypes.length === 0)) {
-            throw new McpError(McpErrorCode.InvalidParams, 'At least one of entityTypes or relationshipTypes must be provided');
-        }
-        this.logger.info('GraphProposeVocabularyTool', `Proposing vocabulary for graph: ${memoryGraphId}`);
-        try {
-            const result = await this.ucmClient.graphProposeVocabulary(memoryGraphId, {
-                // TYPE-EXCEPTION: Zod infers `required?: boolean` but API client expects `required: boolean`;
-                // runtime values are always valid — cast to satisfy the client signature.
-                entityTypes: entityTypes,
-                relationshipTypes: relationshipTypes,
-            });
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            if (error.response?.status === 400) {
-                throw new McpError(McpErrorCode.InvalidParams, error.response.data?.message || 'Validation error');
-            }
-            if (error.response?.status === 404) {
-                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
-            }
-            throw new McpError(McpErrorCode.InternalError, `Failed to propose vocabulary: ${error.message}`);
-        }
-    }
-}
-//# sourceMappingURL=GraphProposeVocabularyTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphSearchTool.js

@@ -1,94 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphSearchSchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphSearchTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_search'; }
-    get description() {
-        return 'Semantic search across one or more Memory Graphs using vector similarity. Uses embeddings if available. Returns entities ranked by relevance to the query concept. Provide memoryGraphId for single-graph search, graphIds (array) for multi-graph search, or omit both to search all accessible graphs.';
-    }
-    get schema() { return GraphSearchSchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                memoryGraphId: {
-                    type: 'string',
-                    description: 'Single Memory Graph ID to search (use this for single-graph search)'
-                },
-                graphIds: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Multiple Memory Graph IDs to search across (use this for multi-graph search)'
-                },
-                query: {
-                    type: 'string',
-                    description: 'Natural language query to search for (will be embedded and compared against entity embeddings)'
-                },
-                entityTypes: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Filter results by entity types'
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results (default: 10, max: 50)'
-                },
-                similarityThreshold: {
-                    type: 'number',
-                    description: 'Minimum similarity score threshold (0-1, default: 0.7)'
-                }
-            },
-            required: ['query']
-        };
-    }
-    async handleExecute(params) {
-        const { memoryGraphId, graphIds, query, entityTypes, limit, similarityThreshold } = params;
-        // Use single-graph search only when memoryGraphId is provided and graphIds is not
-        if (memoryGraphId && !graphIds) {
-            this.logger.info('GraphSearchTool', `Searching single graph: ${memoryGraphId}`);
-            try {
-                const result = await this.ucmClient.graphSearch(memoryGraphId, query, {
-                    entityTypes,
-                    limit,
-                    similarityThreshold
-                });
-                return JSON.stringify(result);
-            }
-            catch (error) {
-                if (error.response?.status === 422) {
-                    const detail = error.response?.data?.message || 'Embeddings are not configured for this Memory Graph';
-                    throw new McpError(McpErrorCode.InvalidRequest, detail);
-                }
-                if (error.response?.status === 404) {
-                    throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
-                }
-                throw new McpError(McpErrorCode.InternalError, `Failed to search graph: ${error.message}`);
-            }
-        }
-        // Multi-graph search: graphIds provided, or neither memoryGraphId nor graphIds provided
-        this.logger.info('GraphSearchTool', `Searching multiple graphs`);
-        try {
-            const result = await this.ucmClient.graphSearchMultiple(query, {
-                graphIds,
-                entityTypes,
-                limit,
-                similarityThreshold
-            });
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            if (error.response?.status === 422) {
-                const detail = error.response?.data?.message || 'Embeddings are not configured for one or more Memory Graphs';
-                throw new McpError(McpErrorCode.InvalidRequest, detail);
-            }
-            if (error.response?.status === 404) {
-                throw new McpError(McpErrorCode.InvalidParams, `One or more Memory Graphs not found`);
-            }
-            throw new McpError(McpErrorCode.InternalError, `Failed to search graphs: ${error.message}`);
-        }
-    }
-}
-//# sourceMappingURL=GraphSearchTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphTraverseTool.d.ts

@@ -1,14 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
-import { ILogger } from '../../interfaces/ILogger.js';
-import { type GraphTraverseParams } from '@/schemas/memory-graph-tool-schemas.js';
-import { ZodSchema } from 'zod';
-export declare class GraphTraverseTool extends BaseToolController {
-    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
-    get name(): string;
-    get description(): string;
-    get schema(): ZodSchema;
-    get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: GraphTraverseParams): Promise<string>;
-}
-//# sourceMappingURL=GraphTraverseTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphTraverseTool.js

@@ -1,114 +0,0 @@
-import { BaseToolController } from '../base/BaseToolController.js';
-import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
-import { GraphTraverseSchema } from '@/schemas/memory-graph-tool-schemas.js';
-export class GraphTraverseTool extends BaseToolController {
-    constructor(ucmClient, logger, publishingAuthorId) {
-        super(ucmClient, logger, publishingAuthorId);
-    }
-    get name() { return 'ucm_graph_traverse'; }
-    get description() {
-        return 'Execute a structured graph traversal using a JSON spec. Supports start point selection, ordered hop steps with relationship/entity type filters, property filters, repeat loops, and multiple return modes (terminal, all, paths). The most powerful query tool for complex graph navigation.';
-    }
-    get schema() { return GraphTraverseSchema; }
-    get inputSchema() {
-        return {
-            type: 'object',
-            properties: {
-                memoryGraphId: {
-                    type: 'string',
-                    description: 'The Memory Graph ID'
-                },
-                start: {
-                    type: 'object',
-                    description: 'Start point specification',
-                    properties: {
-                        entityId: { type: 'string', description: 'Start from a specific entity ID or slug' },
-                        entityType: { type: 'string', description: 'Start from all entities of this type' },
-                        filter: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    key: { type: 'string' },
-                                    operator: { type: 'string', description: 'eq, neq, gt, gte, lt, lte, contains, isNull, isNotNull' },
-                                    value: {}
-                                },
-                                required: ['key', 'operator']
-                            },
-                            description: 'Property filters on start entities'
-                        }
-                    }
-                },
-                steps: {
-                    type: 'array',
-                    description: 'Ordered traversal steps (hops)',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            direction: { type: 'string', enum: ['out', 'in', 'both'], description: 'Hop direction' },
-                            relationshipTypes: { type: 'array', items: { type: 'string' }, description: 'Filter by relationship types' },
-                            entityTypes: { type: 'array', items: { type: 'string' }, description: 'Filter by entity types at this step' },
-                            entityFilter: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        key: { type: 'string' },
-                                        operator: { type: 'string' },
-                                        value: {}
-                                    },
-                                    required: ['key', 'operator']
-                                },
-                                description: 'Property filters on entities at this step'
-                            },
-                            repeat: {
-                                type: 'object',
-                                properties: {
-                                    maxDepth: { type: 'number', description: 'Maximum repeat depth' },
-                                    emitIntermediates: { type: 'boolean', description: 'Include intermediate results' }
-                                },
-                                description: 'Repeat this step up to maxDepth times'
-                            }
-                        }
-                    }
-                },
-                returnMode: {
-                    type: 'string',
-                    enum: ['terminal', 'all', 'path'],
-                    description: 'What to return: terminal (only final step entities), all (every visited entity), path (full traversal paths with relationships). Default: terminal'
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results (default: 50, max: 200)'
-                },
-                detailLevel: {
-                    type: 'string',
-                    enum: ['brief', 'summary', 'full'],
-                    description: 'Detail level for returned entities (default: summary)'
-                }
-            },
-            required: ['memoryGraphId', 'start', 'steps']
-        };
-    }
-    async handleExecute(params) {
-        const { memoryGraphId, start, steps, returnMode, limit, detailLevel } = params;
-        this.logger.info('GraphTraverseTool', `Traversing graph: ${memoryGraphId}`);
-        try {
-            const result = await this.ucmClient.graphTraverse(memoryGraphId, {
-                start,
-                steps,
-                returnMode,
-                limit,
-                detailLevel
-            });
-            return JSON.stringify(result);
-        }
-        catch (error) {
-            if (error.response?.status === 404) {
-                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
-            }
-            throw new McpError(McpErrorCode.InternalError, `Failed to traverse graph: ${error.message}`);
-        }
-    }
-}
-//# sourceMappingURL=GraphTraverseTool.js.map