@ema.co/mcp-toolkit 2026.2.13 → 2026.2.23-1

package/dist/mcp/handlers-consolidated.js

@@ -1,333 +0,0 @@
-/**
- * Consolidated Tool Handlers
- *
- * Each handler dispatches based on mode/flags following Unix CLI patterns.
- */
-// Import shared utilities from handlers module
-import { resolvePersona, } from "./handlers/index.js";
-// Import extracted persona mode handlers
-import { hasExtractedHandler, getPersonaModeHandler, handleVersion, } from "./handlers/persona/index.js";
-// Import extracted handlers (Phase 1 modularization)
-import { handleEnv as handleEnvExtracted } from "./handlers/env/index.js";
-import { handleTemplate as handleTemplateExtracted } from "./handlers/template/index.js";
-import { handleAction as handleActionExtracted } from "./handlers/action/index.js";
-import { handleReference as handleReferenceExtracted } from "./handlers/reference/index.js";
-import { handleKnowledge as handleKnowledgeExtracted } from "./handlers/knowledge/index.js";
-import { handleSync as handleSyncExtracted } from "./handlers/sync/index.js";
-// Import extracted workflow handler (Phase 2 modularization)
-// Note: Imported as "Extracted" to avoid conflict with local definition during transition
-// The local handleWorkflow will be removed once all tests pass
-import { handleWorkflow as handleWorkflowExtracted } from "./handlers/workflow/index.js";
-// Args type imported from handlers/types.ts
-// ─────────────────────────────────────────────────────────────────────────────
-// Generation Templates - MOVED to handlers/data/templates.ts
-// Import via: import { GENERATION_TEMPLATES } from "./handlers/data/templates.js"
-// ─────────────────────────────────────────────────────────────────────────────
-// ─────────────────────────────────────────────────────────────────────────────
-// Widget Validation Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-// isValidWidget and sanitizeWidgets imported from ../sdk/proto-config.js
-// validateWidgetsForApi imported from handlers/utils.ts
-// Deprecation tracking - single source of truth
-import { checkDeprecatedParams, addDeprecationWarnings } from "./handlers/deprecation.js";
-// Template utilities imported from handlers/utils.ts:
-// - normalizeTriggerType
-// - getTemplates
-// - clearTemplateCache
-// - getPersonaTypeFromTemplate
-// ═══════════════════════════════════════════════════════════════════════════
-// Extracted Handler Exports
-// ═══════════════════════════════════════════════════════════════════════════
-// These handlers are fully extracted to handlers/*/ directories.
-// Re-exported here for backwards compatibility with server.ts imports.
-export const handleEnv = handleEnvExtracted;
-export const handleAction = handleActionExtracted;
-export const handleTemplate = handleTemplateExtracted;
-export const handleKnowledge = handleKnowledgeExtracted;
-export const handleReference = handleReferenceExtracted;
-export const handleSync = handleSyncExtracted;
-// ═══════════════════════════════════════════════════════════════════════════
-// PERSONA Handler
-// ═══════════════════════════════════════════════════════════════════════════
-export async function handlePersona(args, client, getTemplateId, createClientForEnv, versionContext) {
-    // Check for deprecated params and log warnings
-    const deprecationWarnings = checkDeprecatedParams(args);
-    for (const warning of deprecationWarnings) {
-        console.warn(`[persona] Deprecation: ${warning}`);
-    }
-    const id = args.id;
-    const identifier = args.identifier; // deprecated alias for 'id'
-    const idOrName = id ?? identifier;
-    // Support both 'method' (new) and 'mode' (legacy) - method takes precedence
-    const method = args.method;
-    const mode = method ?? args.mode;
-    // ═══════════════════════════════════════════════════════════════════════════
-    // DATA SUB-RESOURCE: Handle data={method:...} early
-    // ═══════════════════════════════════════════════════════════════════════════
-    const dataArg = args.data;
-    if (dataArg && typeof dataArg === "object") {
-        // Data operations require persona id
-        if (!idOrName) {
-            return {
-                error: "Data operations require persona id",
-                hint: "Use persona(id=\"abc\", data={method:\"list\"})",
-            };
-        }
-        const dataMethod = dataArg.method;
-        if (!dataMethod) {
-            return {
-                error: "Data operations require explicit method",
-                hint: "Use data={method:\"list|schema|upload|copy|delete|embed|search\", ...}",
-                valid_methods: ["list", "schema", "upload", "copy", "delete", "embed", "search"],
-            };
-        }
-        // Map new method names to existing handlers
-        const methodToMode = {
-            "list": "list",
-            "schema": "schema",
-            "upload": "upload",
-            "copy": "dashboard_clone", // copy → dashboard_clone handler
-            "delete": "delete",
-            "embed": "embed",
-            "search": "search",
-        };
-        const mappedMode = methodToMode[dataMethod];
-        if (!mappedMode) {
-            return {
-                error: `Unknown data method: ${dataMethod}`,
-                valid_methods: Object.keys(methodToMode),
-            };
-        }
-        // Build args for data handler - map new param names to old param names
-        const dataArgs = {
-            persona_id: idOrName,
-            mode: mappedMode,
-        };
-        // Add optional params if present
-        if (dataArg.from)
-            dataArgs.source_persona_id = dataArg.from;
-        if (dataArg.sanitize !== undefined)
-            dataArgs.sanitize = dataArg.sanitize;
-        if (dataArg.path)
-            dataArgs.file_path = dataArg.path;
-        if (dataArg.content)
-            dataArgs.content = dataArg.content;
-        if (dataArg.file_id)
-            dataArgs.file_id = dataArg.file_id;
-        else if (dataArg.id)
-            dataArgs.file_id = dataArg.id; // backwards compat
-        if (dataArg.enabled !== undefined)
-            dataArgs.embed = dataArg.enabled;
-        if (dataArg.query)
-            dataArgs.query = dataArg.query;
-        // Data handler requires readFile function - use fs.readFile
-        const readFile = async (path) => {
-            const fs = await import("fs/promises");
-            return fs.readFile(path);
-        };
-        // Use extracted handler
-        const { handleData: handleDataExtracted } = await import("./handlers/data/index.js");
-        return handleDataExtracted(dataArgs, client, readFile);
-    }
-    // ═══════════════════════════════════════════════════════════════════════════
-    // ROUTING: Persona operations
-    // ═══════════════════════════════════════════════════════════════════════════
-    // ───────────────────────────────────────────────────────────────────────────
-    // LLM-DRIVEN ARCHITECTURE:
-    // - persona tool: config changes only (name, description, widgets)
-    // - workflow tool: ALL workflow changes (get → modify → deploy)
-    // 
-    // The LLM generates the full workflow_def, MCP just deploys it.
-    // There is NO incremental workflow modification via persona tool.
-    // ───────────────────────────────────────────────────────────────────────────
-    // mode="update" → modular handleUpdate (config changes, workflow_spec for rewire/remove only)
-    if (mode === "update" && idOrName) {
-        return getPersonaModeHandler("update")(args, client);
-    }
-    // Legacy: optimize flag routes to workflow handler
-    const optimize = args.optimize;
-    const workflowDef = args.workflow_def ?? args.workflow;
-    if (optimize || (idOrName && workflowDef && mode !== "update")) {
-        const workflowArgs = {
-            ...args,
-            persona_id: idOrName,
-        };
-        delete workflowArgs.id;
-        delete workflowArgs.identifier;
-        return handleWorkflowExtracted(workflowArgs, client, getTemplateId);
-    }
-    // ═══════════════════════════════════════════════════════════════════════════
-    // Standard persona operations (get, list, compare, version management)
-    // ═══════════════════════════════════════════════════════════════════════════
-    // Determine effective mode
-    // Support both new `from` and deprecated `clone_from`/`template_id` parameters
-    const fromParam = args.from;
-    const cloneFromParam = args.clone_from;
-    const templateIdParam = args.template_id;
-    const hasBase = fromParam || cloneFromParam || templateIdParam;
-    // Explicit method required - clarify if not provided
-    let effectiveMode = mode;
-    if (!effectiveMode) {
-        // Provide contextual clarification based on what params were provided
-        const availableMethods = ["list", "get", "create", "update", "delete", "analyze", "sanitize", "snapshot", "history", "restore", "compare"];
-        if (idOrName && args.proto_config) {
-            return {
-                error: "Explicit method required",
-                message: "You provided id and proto_config. Did you want to update this persona?",
-                suggested_method: "update",
-                hint: "Use method='update' to apply changes",
-                example: `persona(method="update", id="${idOrName}", config={...})`,
-            };
-        }
-        else if (idOrName) {
-            return {
-                error: "Explicit method required",
-                message: "You provided a persona id/name. What operation would you like to perform?",
-                valid_methods: ["get", "update", "delete", "sanitize", "snapshot", "history", "restore"],
-                hint: "LLM does analysis/comparison. Use method='get' to fetch data, then reason about it.",
-                example: `persona(method="get", id="${idOrName}")`,
-            };
-        }
-        else if (hasBase || (args.name && args.type)) {
-            return {
-                error: "Explicit method required",
-                message: "You provided creation parameters. Did you want to create a new persona?",
-                suggested_method: "create",
-                hint: "Use method='create'",
-                example: `persona(method="create", name="...", type="voice")`,
-            };
-        }
-        else {
-            return {
-                error: "Explicit method required",
-                message: "All persona operations require explicit method parameter",
-                valid_methods: availableMethods,
-                examples: [
-                    'persona(method="list") - list all personas',
-                    'persona(method="get", id="...") - get specific persona',
-                    'persona(method="create", name="...", type="voice") - create new',
-                    'persona(method="update", id="...", config={...}) - update config',
-                    'persona(method="delete", id="...", confirm=true) - delete',
-                ],
-            };
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Dispatch to extracted handlers (incremental migration)
-    // All standard persona modes are now extracted to handlers/persona/*.ts
-    // Version management modes (version_*) remain in the switch below
-    // ─────────────────────────────────────────────────────────────────────────
-    if (hasExtractedHandler(effectiveMode)) {
-        const handler = getPersonaModeHandler(effectiveMode);
-        if (handler) {
-            // Some handlers need extra context:
-            // - create/clone: needs getTemplateId callback
-            // - compare: needs createClientForEnv callback
-            let extraContext = undefined;
-            if (effectiveMode === "create" || effectiveMode === "clone") {
-                extraContext = getTemplateId;
-            }
-            else if (effectiveMode === "compare") {
-                extraContext = createClientForEnv;
-            }
-            const result = await handler(args, client, extraContext);
-            return addDeprecationWarnings(result, deprecationWarnings);
-        }
-    }
-    switch (effectiveMode) {
-        // NOTE: These modes are now handled by extracted handlers above
-        // These cases are kept as fallback but should not be reached
-        case "get":
-        case "list":
-        case "templates":
-        case "sanitize":
-        case "update":
-        case "delete": {
-            // Should be handled by extracted handlers above
-            return { error: `Mode "${effectiveMode}" should be handled by extracted handler` };
-        }
-        // Schema - get persona input schema (dashboard columns, types)
-        case "schema": {
-            if (!idOrName) {
-                return { error: "id required for schema mode" };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            try {
-                // For dashboard personas, get schema from dashboard
-                const schema = await client.getDashboardSchema(persona.id, persona.id);
-                return {
-                    mode: "schema",
-                    persona_id: persona.id,
-                    persona_name: persona.name,
-                    schema: schema,
-                    column_count: schema.columns?.length ?? 0,
-                };
-            }
-            catch (error) {
-                return { error: `Failed to get schema: ${error instanceof Error ? error.message : String(error)}` };
-            }
-        }
-        // Clone and create - handled by extracted handlers
-        case "clone":
-        case "create": {
-            // These modes have been extracted to handlers/persona/*.ts
-            // - create.ts: handleCreate (~410 lines)
-            return { error: `Mode "${effectiveMode}" should be handled by extracted handler` };
-        }
-        // Analyze and compare - LLM does this, not MCP
-        case "analyze":
-        case "compare": {
-            return {
-                error: `Method "${effectiveMode}" removed - LLM does analysis/comparison`,
-                hint: "Use method='get' to fetch persona data, then do your own analysis/comparison.",
-                example: `persona(method="get", id="...", include_workflow=true)`,
-            };
-        }
-        // ─────────────── Version Management Modes ───────────────
-        // Extracted to handlers/persona/version.ts
-        case "snapshot":
-        case "history":
-        case "restore":
-        case "version_create":
-        case "version_list":
-        case "version_get":
-        case "version_compare":
-        case "version_restore":
-        case "version_policy": {
-            if (!idOrName) {
-                return { error: `id required for ${effectiveMode} mode` };
-            }
-            if (!versionContext) {
-                return { error: "Version tracking not configured. Provide workspaceRoot in context." };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            return handleVersion(effectiveMode, args, client, persona, versionContext);
-        }
-        default:
-            return { error: `Unknown mode: ${effectiveMode}` };
-    }
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// WORKFLOW Handler - REMOVED
-// ═══════════════════════════════════════════════════════════════════════════
-// The handleWorkflow function has been fully extracted to handlers/workflow/
-// Import via: import { handleWorkflow } from "./handlers/workflow/index.js"
-//
-// Modular structure:
-// - handlers/workflow/analyze.ts
-// - handlers/workflow/compare.ts
-// - handlers/workflow/compile.ts
-// - handlers/workflow/deploy.ts
-// - handlers/workflow/generate.ts
-// - handlers/workflow/modify.ts
-// - handlers/workflow/optimize.ts
-// - handlers/workflow/index.ts (router)
-// ═══════════════════════════════════════════════════════════════════════════
-// Re-export the extracted handler for backwards compatibility
-export { handleWorkflow } from "./handlers/workflow/index.js";