@aaronsb/kg-cli 0.6.5 → 0.7.0

package/dist/mcp-server.js

@@ -39,6 +39,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -46,9 +49,11 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const client_js_1 = require("./api/client.js");
 const auth_client_js_1 = require("./lib/auth/auth-client.js");
 const mcp_allowlist_js_1 = require("./lib/mcp-allowlist.js");
-const formatters_js_1 = require("./mcp/formatters.js");
+const index_js_2 = require("./mcp/formatters/index.js");
+const graph_operations_js_1 = require("./mcp/graph-operations.js");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const package_json_1 = __importDefault(require("../package.json"));
 /**
  * Default parameters for graph queries (ADR-048 Query Safety)
  *
@@ -64,7 +69,7 @@ const DEFAULT_MAX_DEPTH = 2; // Related concepts neighborhood depth
 // Create server instance
 const server = new index_js_1.Server({
     name: 'knowledge-graph-server',
-    version: '0.1.0',
+    version: package_json_1.default.version,
 }, {
     capabilities: {
         tools: {},
@@ -403,28 +408,56 @@ PERFORMANCE CRITICAL: For "connect" action, use threshold >= 0.75 to avoid datab
             },
             {
                 name: 'job',
-                description: 'Manage ingestion jobs: get status, list jobs, approve, or cancel. Use action parameter to specify operation.',
+                description: 'Manage ingestion jobs: get status, list jobs, approve, cancel, delete, or cleanup. Use action parameter to specify operation.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         action: {
                             type: 'string',
-                            enum: ['status', 'list', 'approve', 'cancel'],
-                            description: 'Operation: "status" (get job status), "list" (list jobs), "approve" (approve job), "cancel" (cancel job)',
+                            enum: ['status', 'list', 'approve', 'cancel', 'delete', 'cleanup'],
+                            description: 'Operation: "status" (get job status), "list" (list jobs), "approve" (approve job), "cancel" (cancel job), "delete" (permanently delete single job), "cleanup" (delete jobs matching filters)',
                         },
                         job_id: {
                             type: 'string',
-                            description: 'Job ID (required for status, approve, cancel)',
+                            description: 'Job ID (required for status, approve, cancel, delete)',
                         },
                         status: {
                             type: 'string',
-                            description: 'Filter by status for list (pending, awaiting_approval, running, completed, failed)',
+                            description: 'Filter by status for list/cleanup (pending, awaiting_approval, running, completed, failed)',
                         },
                         limit: {
                             type: 'number',
                             description: 'Max jobs to return for list (default: 50)',
                             default: 50,
                         },
+                        force: {
+                            type: 'boolean',
+                            description: 'Force delete even if job is processing (for delete action)',
+                            default: false,
+                        },
+                        system_only: {
+                            type: 'boolean',
+                            description: 'Only delete system/scheduled jobs (for cleanup action)',
+                            default: false,
+                        },
+                        older_than: {
+                            type: 'string',
+                            description: 'Delete jobs older than duration: 1h, 24h, 7d, 30d (for cleanup action)',
+                        },
+                        job_type: {
+                            type: 'string',
+                            description: 'Filter by job type for cleanup (ingestion, epistemic_remeasurement, projection, etc)',
+                        },
+                        dry_run: {
+                            type: 'boolean',
+                            description: 'Preview what would be deleted without deleting (for cleanup, default: true)',
+                            default: true,
+                        },
+                        confirm: {
+                            type: 'boolean',
+                            description: 'Confirm deletion - set to true to actually delete (for cleanup action)',
+                            default: false,
+                        },
                     },
                     required: ['action'],
                 },
@@ -745,6 +778,193 @@ Use search tool with type="documents" to find documents semantically.`,
                     required: ['action'],
                 },
             },
+            // ADR-089 Phase 3a: Graph CRUD Tool
+            {
+                name: 'graph',
+                description: `Create, edit, delete, and list concepts and edges in the knowledge graph (ADR-089).
+
+This tool provides deterministic graph editing without going through the LLM ingest pipeline.
+Use for manual curation, agent-driven knowledge building, and precise graph manipulation.
+
+**Actions:**
+- "create": Create a new concept or edge
+- "edit": Update an existing concept or edge
+- "delete": Delete a concept or edge
+- "list": List concepts or edges with filters
+
+**Entity Types:**
+- "concept": Knowledge graph concepts (nodes)
+- "edge": Relationships between concepts
+
+**Matching Modes (for create):**
+- "auto": Link to existing if match found, create if not (default)
+- "force_create": Always create new, even if similar exists
+- "match_only": Only link to existing, error if no match
+
+**Semantic Resolution:**
+- Use \`from_label\`/\`to_label\` to reference concepts by name instead of ID
+- Resolution uses vector similarity (85% threshold) to find matching concepts
+
+**Examples:**
+- Create concept: \`{action: "create", entity: "concept", label: "CAP Theorem", ontology: "distributed-systems"}\`
+- Create edge: \`{action: "create", entity: "edge", from_label: "CAP Theorem", to_label: "Partition Tolerance", relationship_type: "REQUIRES"}\`
+- List concepts: \`{action: "list", entity: "concept", ontology: "distributed-systems"}\`
+- Delete concept: \`{action: "delete", entity: "concept", concept_id: "c_abc123"}\`
+
+**Queue Mode** (batch multiple operations in one call):
+\`\`\`json
+{
+  "action": "queue",
+  "operations": [
+    {"op": "create", "entity": "concept", "label": "A", "ontology": "test"},
+    {"op": "create", "entity": "concept", "label": "B", "ontology": "test"},
+    {"op": "create", "entity": "edge", "from_label": "A", "to_label": "B", "relationship_type": "IMPLIES"}
+  ]
+}
+\`\`\`
+Queue executes sequentially, stops on first error (unless continue_on_error=true). Max 20 operations.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['create', 'edit', 'delete', 'list', 'queue'],
+                            description: 'Operation to perform. Use "queue" to batch multiple operations.',
+                        },
+                        entity: {
+                            type: 'string',
+                            enum: ['concept', 'edge'],
+                            description: 'Entity type (required for create/edit/delete/list, not for queue)',
+                        },
+                        // Queue fields
+                        operations: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    op: { type: 'string', enum: ['create', 'edit', 'delete', 'list'], description: 'Operation' },
+                                    entity: { type: 'string', enum: ['concept', 'edge'] },
+                                    label: { type: 'string' },
+                                    ontology: { type: 'string' },
+                                    description: { type: 'string' },
+                                    search_terms: { type: 'array', items: { type: 'string' } },
+                                    matching_mode: { type: 'string', enum: ['auto', 'force_create', 'match_only'] },
+                                    concept_id: { type: 'string' },
+                                    from_concept_id: { type: 'string' },
+                                    to_concept_id: { type: 'string' },
+                                    from_label: { type: 'string' },
+                                    to_label: { type: 'string' },
+                                    relationship_type: { type: 'string' },
+                                    category: { type: 'string' },
+                                    confidence: { type: 'number' },
+                                    limit: { type: 'number' },
+                                    offset: { type: 'number' },
+                                    cascade: { type: 'boolean' },
+                                },
+                                required: ['op', 'entity'],
+                            },
+                            description: 'Array of operations for queue action (max 20). Each has op, entity, and action-specific fields.',
+                        },
+                        continue_on_error: {
+                            type: 'boolean',
+                            description: 'For queue: continue executing after errors (default: false, stop on first error)',
+                            default: false,
+                        },
+                        // Concept fields
+                        label: {
+                            type: 'string',
+                            description: 'Concept label (required for create concept)',
+                        },
+                        ontology: {
+                            type: 'string',
+                            description: 'Ontology/namespace (required for create concept, optional filter for list)',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Concept description (optional)',
+                        },
+                        search_terms: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Alternative search terms for the concept',
+                        },
+                        matching_mode: {
+                            type: 'string',
+                            enum: ['auto', 'force_create', 'match_only'],
+                            description: 'How to handle similar existing concepts (default: auto)',
+                            default: 'auto',
+                        },
+                        // Edge fields
+                        from_concept_id: {
+                            type: 'string',
+                            description: 'Source concept ID (for edge create/delete)',
+                        },
+                        to_concept_id: {
+                            type: 'string',
+                            description: 'Target concept ID (for edge create/delete)',
+                        },
+                        from_label: {
+                            type: 'string',
+                            description: 'Source concept by label (semantic resolution)',
+                        },
+                        to_label: {
+                            type: 'string',
+                            description: 'Target concept by label (semantic resolution)',
+                        },
+                        relationship_type: {
+                            type: 'string',
+                            description: 'Edge relationship type (e.g., IMPLIES, SUPPORTS, CONTRADICTS)',
+                        },
+                        category: {
+                            type: 'string',
+                            enum: ['logical_truth', 'empirical_claim', 'value_judgment', 'conceptual', 'temporal_sequence', 'causal', 'other'],
+                            description: 'Semantic category of the relationship (default: logical_truth)',
+                            default: 'logical_truth',
+                        },
+                        confidence: {
+                            type: 'number',
+                            description: 'Edge confidence 0.0-1.0 (default: 1.0)',
+                            default: 1.0,
+                        },
+                        // Identifiers for edit/delete
+                        concept_id: {
+                            type: 'string',
+                            description: 'Concept ID (for edit/delete concept)',
+                        },
+                        // List filters
+                        label_contains: {
+                            type: 'string',
+                            description: 'Filter concepts by label substring (for list)',
+                        },
+                        creation_method: {
+                            type: 'string',
+                            description: 'Filter by creation method (for list)',
+                        },
+                        source: {
+                            type: 'string',
+                            description: 'Filter edges by source (for list)',
+                        },
+                        // Pagination
+                        limit: {
+                            type: 'number',
+                            description: 'Max results to return (default: 20)',
+                            default: 20,
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Number to skip for pagination (default: 0)',
+                            default: 0,
+                        },
+                        // Delete option
+                        cascade: {
+                            type: 'boolean',
+                            description: 'For concept delete: also delete orphaned synthetic sources (default: false)',
+                            default: false,
+                        },
+                    },
+                    required: ['action'],
+                },
+            },
         ],
     };
 });
@@ -802,7 +1022,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatDatabaseStats)(result)
+                            text: (0, index_js_2.formatDatabaseStats)(result)
                         }]
                 };
             }
@@ -812,7 +1032,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatDatabaseInfo)(result)
+                            text: (0, index_js_2.formatDatabaseInfo)(result)
                         }]
                 };
             }
@@ -822,7 +1042,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatDatabaseHealth)(result)
+                            text: (0, index_js_2.formatDatabaseHealth)(result)
                         }]
                 };
             }
@@ -832,7 +1052,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatSystemStatus)(result)
+                            text: (0, index_js_2.formatSystemStatus)(result)
                         }]
                 };
             }
@@ -842,7 +1062,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatApiHealth)(result)
+                            text: (0, index_js_2.formatApiHealth)(result)
                         }]
                 };
             }
@@ -854,7 +1074,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                         contents: [{
                                 uri,
                                 mimeType: 'text/plain',
-                                text: (0, formatters_js_1.formatMcpAllowedPaths)({
+                                text: (0, index_js_2.formatMcpAllowedPaths)({
                                     configured: false,
                                     message: 'Allowlist not initialized. Run: kg mcp-config init-allowlist',
                                     hint: 'Initialize with default safe patterns for .md, .txt, .pdf, .png, .jpg files'
@@ -866,7 +1086,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatMcpAllowedPaths)({
+                            text: (0, index_js_2.formatMcpAllowedPaths)({
                                 configured: true,
                                 version: config.version,
                                 allowed_directories: config.allowed_directories,
@@ -944,7 +1164,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         include_concepts: true,
                         include_full_text: true,
                     });
-                    const formattedText = (0, formatters_js_1.formatSourceSearchResults)(result);
+                    const formattedText = (0, index_js_2.formatSourceSearchResults)(result);
                     return {
                         content: [{ type: 'text', text: formattedText }],
                     };
@@ -959,7 +1179,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     });
                     // Add query to result for formatting
                     const resultWithQuery = { ...result, query };
-                    const formattedText = (0, formatters_js_1.formatDocumentSearchResults)(resultWithQuery);
+                    const formattedText = (0, index_js_2.formatDocumentSearchResults)(resultWithQuery);
                     return {
                         content: [{ type: 'text', text: formattedText }],
                     };
@@ -976,7 +1196,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         include_diversity: true,
                         diversity_max_hops: 2,
                     });
-                    const formattedText = (0, formatters_js_1.formatSearchResults)(result);
+                    const formattedText = (0, index_js_2.formatSearchResults)(result);
                     return {
                         content: [{ type: 'text', text: formattedText }],
                     };
@@ -991,7 +1211,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         const diversityMaxHops = toolArgs.diversity_max_hops || 2;
                         const truncateEvidence = toolArgs.truncate_evidence !== false; // Default true
                         const result = await client.getConceptDetails(toolArgs.concept_id, includeGrounding, includeDiversity, diversityMaxHops);
-                        const formattedText = (0, formatters_js_1.formatConceptDetails)(result, truncateEvidence);
+                        const formattedText = (0, index_js_2.formatConceptDetails)(result, truncateEvidence);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1005,7 +1225,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             include_epistemic_status: toolArgs.include_epistemic_status,
                             exclude_epistemic_status: toolArgs.exclude_epistemic_status,
                         });
-                        const formattedText = (0, formatters_js_1.formatRelatedConcepts)(result);
+                        const formattedText = (0, index_js_2.formatRelatedConcepts)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1041,7 +1261,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                                 include_epistemic_status: toolArgs.include_epistemic_status,
                                 exclude_epistemic_status: toolArgs.exclude_epistemic_status,
                             });
-                            const formattedText = (0, formatters_js_1.formatConnectionPaths)(result);
+                            const formattedText = (0, index_js_2.formatConnectionPaths)(result);
                             return {
                                 content: [{ type: 'text', text: formattedText }],
                             };
@@ -1087,14 +1307,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 switch (action) {
                     case 'status': {
                         const result = await client.getJobStatus(toolArgs.job_id);
-                        const formattedText = (0, formatters_js_1.formatJobStatus)(result);
+                        const formattedText = (0, index_js_2.formatJobStatus)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
                     }
                     case 'list': {
                         const result = await client.listJobs(toolArgs.status, undefined, toolArgs.limit || 50);
-                        const formattedText = (0, formatters_js_1.formatJobList)(result);
+                        const formattedText = (0, index_js_2.formatJobList)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1111,6 +1331,49 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'delete': {
+                        const result = await client.deleteJob(toolArgs.job_id, {
+                            purge: true,
+                            force: toolArgs.force || false
+                        });
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'cleanup': {
+                        const result = await client.deleteJobs({
+                            dryRun: toolArgs.dry_run !== false && !toolArgs.confirm,
+                            confirm: toolArgs.confirm || false,
+                            status: toolArgs.status,
+                            system: toolArgs.system_only || false,
+                            olderThan: toolArgs.older_than,
+                            jobType: toolArgs.job_type
+                        });
+                        let output = '';
+                        if (result.dry_run) {
+                            output = `## Cleanup Preview (dry run)\n\n`;
+                            output += `Jobs matching filters: ${result.jobs_to_delete}\n\n`;
+                            if (result.jobs && result.jobs.length > 0) {
+                                output += `| Job ID | Type | Status | Created |\n`;
+                                output += `|--------|------|--------|--------|\n`;
+                                for (const job of result.jobs.slice(0, 20)) {
+                                    output += `| ${job.job_id.substring(0, 16)} | ${job.job_type} | ${job.status} | ${job.created_at} |\n`;
+                                }
+                                if (result.jobs.length > 20) {
+                                    output += `\n... and ${result.jobs.length - 20} more\n`;
+                                }
+                            }
+                            output += `\nTo delete, use confirm: true`;
+                        }
+                        else {
+                            output = `## Cleanup Complete\n\n`;
+                            output += `Jobs deleted: ${result.jobs_deleted}\n`;
+                            output += `\n${result.message}`;
+                        }
+                        return {
+                            content: [{ type: 'text', text: output }],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown job action: ${action}`);
                 }
@@ -1197,7 +1460,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [
                                 {
                                     type: 'text',
-                                    text: (0, formatters_js_1.formatInspectFileResult)(result),
+                                    text: (0, index_js_2.formatInspectFileResult)(result),
                                 },
                             ],
                         };
@@ -1293,7 +1556,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [
                                 {
                                     type: 'text',
-                                    text: (0, formatters_js_1.formatIngestFileResult)(result),
+                                    text: (0, index_js_2.formatIngestFileResult)(result),
                                 },
                             ],
                         };
@@ -1376,7 +1639,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [
                                 {
                                     type: 'text',
-                                    text: (0, formatters_js_1.formatIngestDirectoryResult)(result),
+                                    text: (0, index_js_2.formatIngestDirectoryResult)(result),
                                 },
                             ],
                         };
@@ -1445,7 +1708,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     case 'list': {
                         const statusFilter = toolArgs.status_filter;
                         const result = await client.listEpistemicStatus(statusFilter);
-                        const output = (0, formatters_js_1.formatEpistemicStatusList)(result);
+                        const output = (0, index_js_2.formatEpistemicStatusList)(result);
                         return {
                             content: [{ type: 'text', text: output }],
                         };
@@ -1456,7 +1719,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             throw new Error('relationship_type is required for show action');
                         }
                         const result = await client.getEpistemicStatus(relationshipType);
-                        const output = (0, formatters_js_1.formatEpistemicStatusDetails)(result);
+                        const output = (0, index_js_2.formatEpistemicStatusDetails)(result);
                         return {
                             content: [{ type: 'text', text: output }],
                         };
@@ -1470,7 +1733,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             store: store,
                             verbose: verbose,
                         });
-                        const output = (0, formatters_js_1.formatEpistemicStatusMeasurement)(result);
+                        const output = (0, index_js_2.formatEpistemicStatusMeasurement)(result);
                         return {
                             content: [{ type: 'text', text: output }],
                         };
@@ -1488,7 +1751,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     max_candidates: toolArgs.max_candidates || 20,
                     max_hops: toolArgs.max_hops || 2,
                 });
-                const formattedText = (0, formatters_js_1.formatPolarityAxisResults)(result);
+                const formattedText = (0, index_js_2.formatPolarityAxisResults)(result);
                 return {
                     content: [{ type: 'text', text: formattedText }],
                 };
@@ -1592,7 +1855,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             limit: toolArgs.limit || 50,
                             offset: toolArgs.offset || 0,
                         });
-                        const formattedText = (0, formatters_js_1.formatDocumentList)(result);
+                        const formattedText = (0, index_js_2.formatDocumentList)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1603,7 +1866,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             throw new Error('document_id is required for show action');
                         }
                         const result = await client.getDocumentContent(documentId);
-                        const formattedText = (0, formatters_js_1.formatDocumentContent)(result);
+                        const formattedText = (0, index_js_2.formatDocumentContent)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1632,13 +1895,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                                     });
                                 }
                             }
-                            const formattedText = (0, formatters_js_1.formatDocumentConceptsDetailed)(result, conceptDetails);
+                            const formattedText = (0, index_js_2.formatDocumentConceptsDetailed)(result, conceptDetails);
                             return {
                                 content: [{ type: 'text', text: formattedText }],
                             };
                         }
                         else {
-                            const formattedText = (0, formatters_js_1.formatDocumentConcepts)(result);
+                            const formattedText = (0, index_js_2.formatDocumentConcepts)(result);
                             return {
                                 content: [{ type: 'text', text: formattedText }],
                             };
@@ -1648,6 +1911,175 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         throw new Error(`Unknown document action: ${action}`);
                 }
             }
+            // ADR-089 Phase 3a: Graph CRUD Tool Handler (Refactored)
+            case 'graph': {
+                const action = toolArgs.action;
+                const entity = toolArgs.entity;
+                // Entity required for all actions except queue
+                if (action !== 'queue' && !entity) {
+                    throw new Error('entity is required (concept or edge)');
+                }
+                // Create executor instance for this request
+                const executor = new graph_operations_js_1.GraphOperationExecutor(client);
+                switch (action) {
+                    case 'create': {
+                        if (entity === 'concept') {
+                            const result = await executor.createConcept({
+                                label: toolArgs.label,
+                                ontology: toolArgs.ontology,
+                                description: toolArgs.description,
+                                search_terms: toolArgs.search_terms,
+                                matching_mode: toolArgs.matching_mode,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptResult)(result.data, 'create') }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.createEdge({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                                category: toolArgs.category,
+                                confidence: toolArgs.confidence,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeResult)(result.data, 'create') }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'list': {
+                        if (entity === 'concept') {
+                            const result = await executor.listConcepts({
+                                ontology: toolArgs.ontology,
+                                label_contains: toolArgs.label_contains,
+                                creation_method: toolArgs.creation_method,
+                                offset: toolArgs.offset,
+                                limit: toolArgs.limit,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptList)(result.data) }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.listEdges({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                                category: toolArgs.category,
+                                source: toolArgs.source,
+                                offset: toolArgs.offset,
+                                limit: toolArgs.limit,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeList)(result.data) }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'edit': {
+                        if (entity === 'concept') {
+                            const result = await executor.editConcept({
+                                concept_id: toolArgs.concept_id,
+                                label: toolArgs.label,
+                                description: toolArgs.description,
+                                search_terms: toolArgs.search_terms,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptResult)(result.data, 'edit') }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.editEdge({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                                confidence: toolArgs.confidence,
+                                category: toolArgs.category,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeResult)(result.data, 'edit') }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'delete': {
+                        if (entity === 'concept') {
+                            const result = await executor.deleteConcept({
+                                concept_id: toolArgs.concept_id,
+                                cascade: toolArgs.cascade,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptResult)(result.data, 'delete') }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.deleteEdge({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeResult)(result.data, 'delete') }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'queue': {
+                        const operations = toolArgs.operations;
+                        const continueOnError = toolArgs.continue_on_error === true;
+                        if (!operations || !Array.isArray(operations)) {
+                            throw new Error('operations array is required for queue action');
+                        }
+                        if (operations.length === 0) {
+                            throw new Error('operations array cannot be empty');
+                        }
+                        if (operations.length > 20) {
+                            throw new Error(`Queue too large: ${operations.length} operations (max 20)`);
+                        }
+                        const queueResult = await executor.executeQueue(operations, continueOnError);
+                        const formattedOutput = (0, index_js_2.formatGraphQueueResult)(queueResult, operations.length);
+                        return {
+                            content: [{ type: 'text', text: formattedOutput }],
+                        };
+                    }
+                    default:
+                        throw new Error(`Unknown graph action: ${action}. Use: create, edit, delete, list, or queue`);
+                }
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }