n8n-atom-mcp 0.0.1

package/dist/mcp/tool-docs/guides/ai-agents-guide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-agents-guide.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/guides/ai-agents-guide.ts"],"names":[],"mappings":";;;AAEa,QAAA,aAAa,GAAsB;IAC9C,IAAI,EAAE,iBAAiB;IACvB,QAAQ,EAAE,QAAQ;IAClB,UAAU,EAAE;QACV,WAAW,EAAE,+JAA+J;QAC5K,aAAa,EAAE,EAAE;QACjB,OAAO,EAAE,0EAA0E;QACnF,WAAW,EAAE,0BAA0B;QACvC,IAAI,EAAE;YACJ,6DAA6D;YAC7D,wDAAwD;YACxD,8DAA8D;YAC9D,iEAAiE;YACjE,sDAAsD;YACtD,6DAA6D;SAC9D;KACF;IACD,IAAI,EAAE;QACJ,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uKAoqBsJ;QACnK,UAAU,EAAE,EAAE;QACd,OAAO,EAAE,uFAAuF;QAChG,QAAQ,EAAE;YACR,8DAA8D;YAC9D,wFAAwF;YACxF,8FAA8F;SAC/F;QACD,QAAQ,EAAE;YACR,uCAAuC;YACvC,gDAAgD;YAChD,+CAA+C;YAC/C,wEAAwE;YACxE,oCAAoC;YACpC,2CAA2C;YAC3C,gDAAgD;SACjD;QACD,WAAW,EAAE,4BAA4B;QACzC,aAAa,EAAE;YACb,qDAAqD;YACrD,gDAAgD;YAChD,sEAAsE;YACtE,uDAAuD;YACvD,2DAA2D;SAC5D;QACD,QAAQ,EAAE;YACR,yCAAyC;YACzC,gDAAgD;YAChD,+CAA+C;YAC/C,yCAAyC;YACzC,6DAA6D;SAC9D;QACD,YAAY,EAAE;YACZ,qBAAqB;YACrB,6BAA6B;YAC7B,uBAAuB;YACvB,cAAc;YACd,UAAU;SACX;KACF;CACF,CAAC"}

package/dist/mcp/tool-docs/guides/index.d.ts

@@ -0,0 +1,2 @@
+export { aiAgentsGuide } from './ai-agents-guide';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/tool-docs/guides/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/guides/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/mcp/tool-docs/guides/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiAgentsGuide = void 0;
+var ai_agents_guide_1 = require("./ai-agents-guide");
+Object.defineProperty(exports, "aiAgentsGuide", { enumerable: true, get: function () { return ai_agents_guide_1.aiAgentsGuide; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/tool-docs/guides/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/guides/index.ts"],"names":[],"mappings":";;;AACA,qDAAkD;AAAzC,gHAAA,aAAa,OAAA"}

package/dist/mcp/tool-docs/index.d.ts

@@ -0,0 +1,4 @@
+import { ToolDocumentation } from './types';
+export declare const toolsDocumentation: Record<string, ToolDocumentation>;
+export type { ToolDocumentation } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/tool-docs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mcp/tool-docs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AA4B5C,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAmChE,CAAC;AAGF,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/mcp/tool-docs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolsDocumentation = void 0;
+const discovery_1 = require("./discovery");
+const configuration_1 = require("./configuration");
+const validation_1 = require("./validation");
+const templates_1 = require("./templates");
+const system_1 = require("./system");
+const guides_1 = require("./guides");
+const workflow_management_1 = require("./workflow_management");
+exports.toolsDocumentation = {
+    tools_documentation: system_1.toolsDocumentationDoc,
+    n8n_health_check: system_1.n8nHealthCheckDoc,
+    ai_agents_guide: guides_1.aiAgentsGuide,
+    search_nodes: discovery_1.searchNodesDoc,
+    get_node: configuration_1.getNodeDoc,
+    validate_node: validation_1.validateNodeDoc,
+    validate_workflow: validation_1.validateWorkflowDoc,
+    get_template: templates_1.getTemplateDoc,
+    search_templates: templates_1.searchTemplatesDoc,
+    n8n_create_workflow: workflow_management_1.n8nCreateWorkflowDoc,
+    n8n_get_workflow: workflow_management_1.n8nGetWorkflowDoc,
+    n8n_update_full_workflow: workflow_management_1.n8nUpdateFullWorkflowDoc,
+    n8n_update_partial_workflow: workflow_management_1.n8nUpdatePartialWorkflowDoc,
+    n8n_delete_workflow: workflow_management_1.n8nDeleteWorkflowDoc,
+    n8n_list_workflows: workflow_management_1.n8nListWorkflowsDoc,
+    n8n_validate_workflow: workflow_management_1.n8nValidateWorkflowDoc,
+    n8n_autofix_workflow: workflow_management_1.n8nAutofixWorkflowDoc,
+    n8n_test_workflow: workflow_management_1.n8nTestWorkflowDoc,
+    n8n_executions: workflow_management_1.n8nExecutionsDoc,
+    n8n_workflow_versions: workflow_management_1.n8nWorkflowVersionsDoc,
+    n8n_deploy_template: workflow_management_1.n8nDeployTemplateDoc
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/tool-docs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcp/tool-docs/index.ts"],"names":[],"mappings":";;;AAGA,2CAA6C;AAC7C,mDAA6C;AAC7C,6CAAoE;AACpE,2CAAiE;AACjE,qCAGkB;AAClB,qCAAyC;AACzC,+DAa+B;AAGlB,QAAA,kBAAkB,GAAsC;IAEnE,mBAAmB,EAAE,8BAAqB;IAC1C,gBAAgB,EAAE,0BAAiB;IAGnC,eAAe,EAAE,sBAAa;IAG9B,YAAY,EAAE,0BAAc;IAG5B,QAAQ,EAAE,0BAAU;IAGpB,aAAa,EAAE,4BAAe;IAC9B,iBAAiB,EAAE,gCAAmB;IAGtC,YAAY,EAAE,0BAAc;IAC5B,gBAAgB,EAAE,8BAAkB;IAGpC,mBAAmB,EAAE,0CAAoB;IACzC,gBAAgB,EAAE,uCAAiB;IACnC,wBAAwB,EAAE,8CAAwB;IAClD,2BAA2B,EAAE,iDAA2B;IACxD,mBAAmB,EAAE,0CAAoB;IACzC,kBAAkB,EAAE,yCAAmB;IACvC,qBAAqB,EAAE,4CAAsB;IAC7C,oBAAoB,EAAE,2CAAqB;IAC3C,iBAAiB,EAAE,wCAAkB;IACrC,cAAc,EAAE,sCAAgB;IAChC,qBAAqB,EAAE,4CAAsB;IAC7C,mBAAmB,EAAE,0CAAoB;CAC1C,CAAC"}

package/dist/mcp/tool-docs/system/index.d.ts

@@ -0,0 +1,3 @@
+export { toolsDocumentationDoc } from './tools-documentation';
+export { n8nHealthCheckDoc } from './n8n-health-check';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/tool-docs/system/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/mcp/tool-docs/system/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.n8nHealthCheckDoc = exports.toolsDocumentationDoc = void 0;
+var tools_documentation_1 = require("./tools-documentation");
+Object.defineProperty(exports, "toolsDocumentationDoc", { enumerable: true, get: function () { return tools_documentation_1.toolsDocumentationDoc; } });
+var n8n_health_check_1 = require("./n8n-health-check");
+Object.defineProperty(exports, "n8nHealthCheckDoc", { enumerable: true, get: function () { return n8n_health_check_1.n8nHealthCheckDoc; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/tool-docs/system/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/index.ts"],"names":[],"mappings":";;;AAAA,6DAA8D;AAArD,4HAAA,qBAAqB,OAAA;AAC9B,uDAAuD;AAA9C,qHAAA,iBAAiB,OAAA"}

package/dist/mcp/tool-docs/system/n8n-diagnostic.d.ts

@@ -0,0 +1,3 @@
+import { ToolDocumentation } from '../types';
+export declare const n8nDiagnosticDoc: ToolDocumentation;
+//# sourceMappingURL=n8n-diagnostic.d.ts.map

package/dist/mcp/tool-docs/system/n8n-diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8n-diagnostic.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/n8n-diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,gBAAgB,EAAE,iBA8F9B,CAAC"}

package/dist/mcp/tool-docs/system/n8n-diagnostic.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.n8nDiagnosticDoc = void 0;
+exports.n8nDiagnosticDoc = {
+    name: 'n8n_diagnostic',
+    category: 'system',
+    essentials: {
+        description: 'Comprehensive diagnostic with environment-aware debugging, version checks, performance metrics, and mode-specific troubleshooting',
+        keyParameters: ['verbose'],
+        example: 'n8n_diagnostic({verbose: true})',
+        performance: 'Fast - checks environment, API, and npm version (~180ms median)',
+        tips: [
+            'Now includes environment-aware debugging based on MCP_MODE (http/stdio)',
+            'Provides mode-specific troubleshooting (HTTP server vs Claude Desktop)',
+            'Detects Docker and cloud platforms for targeted guidance',
+            'Shows performance metrics: response time and cache statistics',
+            'Includes data-driven tips based on 82% user success rate'
+        ]
+    },
+    full: {
+        description: `Comprehensive diagnostic tool for troubleshooting n8n API configuration and management tool availability.
+
+This tool performs a detailed check of:
+- Environment variable configuration (N8N_API_URL, N8N_API_KEY)
+- API connectivity and authentication
+- Tool availability status
+- Common configuration issues
+
+The diagnostic is essential when:
+- n8n management tools aren't showing up in the available tools list
+- API calls are failing with authentication or connection errors
+- You need to verify your n8n instance configuration`,
+        parameters: {
+            verbose: {
+                type: 'boolean',
+                description: 'Include detailed debug information including full environment variables and API response details',
+                required: false,
+                default: false
+            }
+        },
+        returns: `Comprehensive diagnostic report containing:
+- timestamp: ISO timestamp of diagnostic run
+- environment: Enhanced environment variables
+  - N8N_API_URL, N8N_API_KEY (masked), NODE_ENV, MCP_MODE
+  - isDocker: Boolean indicating if running in Docker
+  - cloudPlatform: Detected cloud platform (railway/render/fly/etc.) or null
+  - nodeVersion: Node.js version
+  - platform: OS platform (darwin/win32/linux)
+- apiConfiguration: API configuration and connectivity status
+  - configured, status (connected/error/version), config details
+- versionInfo: Version check results (current, latest, upToDate, message, updateCommand)
+- toolsAvailability: Tool availability breakdown (doc tools + management tools)
+- performance: Performance metrics (responseTimeMs, cacheHitRate, cachedInstances)
+- modeSpecificDebug: Mode-specific debugging (ALWAYS PRESENT)
+  - HTTP mode: port, authTokenConfigured, serverUrl, healthCheckUrl, troubleshooting steps, commonIssues
+  - stdio mode: configLocation, troubleshooting steps, commonIssues
+- dockerDebug: Docker-specific guidance (if IS_DOCKER=true)
+  - containerDetected, troubleshooting steps, commonIssues
+- cloudPlatformDebug: Cloud platform-specific tips (if platform detected)
+  - name, troubleshooting steps tailored to platform (Railway/Render/Fly/K8s/AWS/etc.)
+- nextSteps: Context-specific guidance (if API connected)
+- troubleshooting: Troubleshooting guidance (if API not connecting)
+- setupGuide: Setup guidance (if API not configured)
+- updateWarning: Update recommendation (if version outdated)
+- debug: Verbose debug information (if verbose=true)`,
+        examples: [
+            'n8n_diagnostic({}) - Quick diagnostic check',
+            'n8n_diagnostic({verbose: true}) - Detailed diagnostic with environment info',
+            'n8n_diagnostic({verbose: false}) - Standard diagnostic without sensitive data'
+        ],
+        useCases: [
+            'Initial setup verification after configuring N8N_API_URL and N8N_API_KEY',
+            'Troubleshooting when n8n management tools are not available',
+            'Debugging API connection failures or authentication errors',
+            'Verifying n8n instance compatibility and feature availability',
+            'Pre-deployment checks before using workflow management tools'
+        ],
+        performance: `Instant response time:
+- No database queries
+- Only checks environment and makes one test API call
+- Verbose mode adds minimal overhead
+- Safe to run frequently for monitoring`,
+        bestPractices: [
+            'Always run diagnostic first when encountering n8n tool issues',
+            'Use verbose mode only in secure environments (may expose API URLs)',
+            'Check diagnostic before attempting workflow operations',
+            'Include diagnostic output when reporting issues',
+            'Run after any configuration changes to verify setup'
+        ],
+        pitfalls: [
+            'Verbose mode may expose sensitive configuration details - use carefully',
+            'Requires proper environment variables to detect n8n configuration',
+            'API connectivity test requires network access to n8n instance',
+            'Does not test specific workflow operations, only basic connectivity'
+        ],
+        relatedTools: ['n8n_health_check', 'n8n_list_available_tools', 'tools_documentation']
+    }
+};
+//# sourceMappingURL=n8n-diagnostic.js.map

package/dist/mcp/tool-docs/system/n8n-diagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8n-diagnostic.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/n8n-diagnostic.ts"],"names":[],"mappings":";;;AAEa,QAAA,gBAAgB,GAAsB;IACjD,IAAI,EAAE,gBAAgB;IACtB,QAAQ,EAAE,QAAQ;IAClB,UAAU,EAAE;QACV,WAAW,EAAE,mIAAmI;QAChJ,aAAa,EAAE,CAAC,SAAS,CAAC;QAC1B,OAAO,EAAE,iCAAiC;QAC1C,WAAW,EAAE,iEAAiE;QAC9E,IAAI,EAAE;YACJ,yEAAyE;YACzE,wEAAwE;YACxE,0DAA0D;YAC1D,+DAA+D;YAC/D,0DAA0D;SAC3D;KACF;IACD,IAAI,EAAE;QACJ,WAAW,EAAE;;;;;;;;;;;qDAWoC;QACjD,UAAU,EAAE;YACV,OAAO,EAAE;gBACP,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,kGAAkG;gBAC/G,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,KAAK;aACf;SACF;QACD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;qDAwBwC;QACjD,QAAQ,EAAE;YACR,6CAA6C;YAC7C,6EAA6E;YAC7E,+EAA+E;SAChF;QACD,QAAQ,EAAE;YACR,0EAA0E;YAC1E,6DAA6D;YAC7D,4DAA4D;YAC5D,+DAA+D;YAC/D,8DAA8D;SAC/D;QACD,WAAW,EAAE;;;;wCAIuB;QACpC,aAAa,EAAE;YACb,+DAA+D;YAC/D,oEAAoE;YACpE,wDAAwD;YACxD,iDAAiD;YACjD,qDAAqD;SACtD;QACD,QAAQ,EAAE;YACR,yEAAyE;YACzE,mEAAmE;YACnE,+DAA+D;YAC/D,qEAAqE;SACtE;QACD,YAAY,EAAE,CAAC,kBAAkB,EAAE,0BAA0B,EAAE,qBAAqB,CAAC;KACtF;CACF,CAAC"}

package/dist/mcp/tool-docs/system/n8n-health-check.d.ts

@@ -0,0 +1,3 @@
+import { ToolDocumentation } from '../types';
+export declare const n8nHealthCheckDoc: ToolDocumentation;
+//# sourceMappingURL=n8n-health-check.d.ts.map

package/dist/mcp/tool-docs/system/n8n-health-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8n-health-check.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/n8n-health-check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,iBAAiB,EAAE,iBAiG/B,CAAC"}

package/dist/mcp/tool-docs/system/n8n-health-check.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.n8nHealthCheckDoc = void 0;
+exports.n8nHealthCheckDoc = {
+    name: 'n8n_health_check',
+    category: 'system',
+    essentials: {
+        description: 'Check n8n instance health, API connectivity, version status, and performance metrics',
+        keyParameters: ['mode', 'verbose'],
+        example: 'n8n_health_check({mode: "status"})',
+        performance: 'Fast - single API call (~150-200ms median)',
+        tips: [
+            'Use before starting workflow operations to ensure n8n is responsive',
+            'Automatically checks if n8n-atom-mcp version is outdated',
+            'Returns version info, performance metrics, and next-step recommendations',
+            'New: Shows cache hit rate and response time for performance monitoring'
+        ]
+    },
+    full: {
+        description: `Performs a comprehensive health check of the configured n8n instance through its API.
+
+This tool verifies:
+- API endpoint accessibility and response time
+- n8n instance version and build information
+- Authentication status and permissions
+- Available features and enterprise capabilities
+- Database connectivity (as reported by n8n)
+- Queue system status (if configured)
+
+Health checks are crucial for:
+- Monitoring n8n instance availability
+- Detecting performance degradation
+- Verifying API compatibility before operations
+- Ensuring authentication is working correctly`,
+        parameters: {
+            mode: {
+                type: 'string',
+                required: false,
+                description: 'Operation mode: "status" (default) for quick health check, "diagnostic" for detailed debug info including env vars and tool status',
+                default: 'status',
+                enum: ['status', 'diagnostic']
+            },
+            verbose: {
+                type: 'boolean',
+                required: false,
+                description: 'Include extra details in diagnostic mode',
+                default: false
+            }
+        },
+        returns: `Health status object containing:
+- status: Overall health status ('healthy', 'degraded', 'error')
+- n8nVersion: n8n instance version information
+- instanceId: Unique identifier for the n8n instance
+- features: Object listing available features and their status
+- mcpVersion: Current n8n-atom-mcp version
+- supportedN8nVersion: Recommended n8n version for compatibility
+- versionCheck: Version status information
+  - current: Current n8n-atom-mcp version
+  - latest: Latest available version from npm
+  - upToDate: Boolean indicating if version is current
+  - message: Formatted version status message
+  - updateCommand: Command to update (if outdated)
+- performance: Performance metrics
+  - responseTimeMs: API response time in milliseconds
+  - cacheHitRate: Cache efficiency percentage
+  - cachedInstances: Number of cached API instances
+- nextSteps: Recommended actions after health check
+- updateWarning: Warning if version is outdated (if applicable)`,
+        examples: [
+            'n8n_health_check({}) - Complete health check with version and performance data',
+            '// Use in monitoring scripts\nconst health = await n8n_health_check({});\nif (health.status !== "ok") alert("n8n is down!");\nif (!health.versionCheck.upToDate) console.log("Update available:", health.versionCheck.updateCommand);',
+            '// Check before critical operations\nconst health = await n8n_health_check({});\nif (health.performance.responseTimeMs > 1000) console.warn("n8n is slow");\nif (health.versionCheck.isOutdated) console.log(health.updateWarning);'
+        ],
+        useCases: [
+            'Pre-flight checks before workflow deployments',
+            'Continuous monitoring of n8n instance health',
+            'Troubleshooting connectivity or performance issues',
+            'Verifying n8n version compatibility with workflows',
+            'Detecting feature availability (enterprise features, queue mode, etc.)'
+        ],
+        performance: `Fast response expected:
+- Single HTTP request to /health endpoint
+- Typically responds in <100ms for healthy instances
+- Timeout after 10 seconds indicates severe issues
+- Minimal server load - safe for frequent polling`,
+        bestPractices: [
+            'Run health checks before batch operations or deployments',
+            'Set up automated monitoring with regular health checks',
+            'Log response times to detect performance trends',
+            'Check version compatibility when deploying workflows',
+            'Use health status to implement circuit breaker patterns'
+        ],
+        pitfalls: [
+            'Requires N8N_API_URL and N8N_API_KEY to be configured',
+            'Network issues may cause false negatives',
+            'Does not check individual workflow health',
+            'Health endpoint might be cached - not real-time for all metrics'
+        ],
+        relatedTools: ['n8n_list_workflows', 'n8n_validate_workflow', 'n8n_workflow_versions']
+    }
+};
+//# sourceMappingURL=n8n-health-check.js.map

package/dist/mcp/tool-docs/system/n8n-health-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8n-health-check.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/n8n-health-check.ts"],"names":[],"mappings":";;;AAEa,QAAA,iBAAiB,GAAsB;IAClD,IAAI,EAAE,kBAAkB;IACxB,QAAQ,EAAE,QAAQ;IAClB,UAAU,EAAE;QACV,WAAW,EAAE,sFAAsF;QACnG,aAAa,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC;QAClC,OAAO,EAAE,oCAAoC;QAC7C,WAAW,EAAE,4CAA4C;QACzD,IAAI,EAAE;YACJ,qEAAqE;YACrE,0DAA0D;YAC1D,0EAA0E;YAC1E,wEAAwE;SACzE;KACF;IACD,IAAI,EAAE;QACJ,WAAW,EAAE;;;;;;;;;;;;;;+CAc8B;QAC3C,UAAU,EAAE;YACV,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,KAAK;gBACf,WAAW,EAAE,oIAAoI;gBACjJ,OAAO,EAAE,QAAQ;gBACjB,IAAI,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC;aAC/B;YACD,OAAO,EAAE;gBACP,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,KAAK;gBACf,WAAW,EAAE,0CAA0C;gBACvD,OAAO,EAAE,KAAK;aACf;SACF;QACD,OAAO,EAAE;;;;;;;;;;;;;;;;;;gEAkBmD;QAC5D,QAAQ,EAAE;YACR,gFAAgF;YAChF,uOAAuO;YACvO,qOAAqO;SACtO;QACD,QAAQ,EAAE;YACR,+CAA+C;YAC/C,8CAA8C;YAC9C,oDAAoD;YACpD,oDAAoD;YACpD,wEAAwE;SACzE;QACD,WAAW,EAAE;;;;kDAIiC;QAC9C,aAAa,EAAE;YACb,0DAA0D;YAC1D,wDAAwD;YACxD,iDAAiD;YACjD,sDAAsD;YACtD,yDAAyD;SAC1D;QACD,QAAQ,EAAE;YACR,uDAAuD;YACvD,0CAA0C;YAC1C,2CAA2C;YAC3C,iEAAiE;SAClE;QACD,YAAY,EAAE,CAAC,oBAAoB,EAAE,uBAAuB,EAAE,uBAAuB,CAAC;KACvF;CACF,CAAC"}

package/dist/mcp/tool-docs/system/n8n-list-available-tools.d.ts

@@ -0,0 +1,3 @@
+import { ToolDocumentation } from '../types';
+export declare const n8nListAvailableToolsDoc: ToolDocumentation;
+//# sourceMappingURL=n8n-list-available-tools.d.ts.map

package/dist/mcp/tool-docs/system/n8n-list-available-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8n-list-available-tools.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/n8n-list-available-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,wBAAwB,EAAE,iBAsEtC,CAAC"}

package/dist/mcp/tool-docs/system/n8n-list-available-tools.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.n8nListAvailableToolsDoc = void 0;
+exports.n8nListAvailableToolsDoc = {
+    name: 'n8n_list_available_tools',
+    category: 'system',
+    essentials: {
+        description: 'List all available n8n management tools and their capabilities',
+        keyParameters: [],
+        example: 'n8n_list_available_tools({})',
+        performance: 'Instant - returns static tool list',
+        tips: [
+            'Shows only tools available with current API configuration',
+            'If no n8n tools appear, run n8n_diagnostic to troubleshoot',
+            'Tool availability depends on N8N_API_URL and N8N_API_KEY being set'
+        ]
+    },
+    full: {
+        description: `Lists all available n8n management tools based on current configuration.
+
+This tool provides:
+- Complete list of n8n management tools (when API is configured)
+- Tool descriptions and capabilities
+- Categorized tool listing (workflow, execution, system)
+- Dynamic availability based on API configuration
+
+The tool list is dynamic:
+- Shows 14+ management tools when N8N_API_URL and N8N_API_KEY are configured
+- Shows only documentation tools when API is not configured
+- Helps discover available functionality
+- Provides quick reference for tool names and purposes`,
+        parameters: {},
+        returns: `Object containing:
+- tools: Array of available tool objects, each with:
+  - name: Tool identifier (e.g., 'n8n_create_workflow')
+  - description: Brief description of tool functionality
+  - category: Tool category ('workflow', 'execution', 'system')
+  - requiresApi: Whether tool needs API configuration
+- categories: Summary count by category
+- totalTools: Total number of available tools
+- apiConfigured: Whether n8n API is configured`,
+        examples: [
+            'n8n_list_available_tools({}) - List all available tools',
+            '// Check for specific tool availability\nconst tools = await n8n_list_available_tools({});\nconst hasWorkflowTools = tools.tools.some(t => t.category === "workflow");',
+            '// Discover management capabilities\nconst result = await n8n_list_available_tools({});\nconsole.log(`${result.totalTools} tools available`);'
+        ],
+        useCases: [
+            'Discovering available n8n management capabilities',
+            'Checking if API configuration is working correctly',
+            'Finding the right tool for a specific task',
+            'Generating help documentation or command lists',
+            'Verifying tool availability before automation scripts'
+        ],
+        performance: `Instant response:
+- No API calls required
+- Returns pre-defined tool list
+- Filtered based on configuration
+- Zero network overhead`,
+        bestPractices: [
+            'Check tool availability before building automation workflows',
+            'Use with n8n_diagnostic if expected tools are missing',
+            'Reference tool names exactly as returned by this tool',
+            'Group operations by category for better organization',
+            'Cache results as tool list only changes with configuration'
+        ],
+        pitfalls: [
+            'Tool list is empty if N8N_API_URL and N8N_API_KEY are not set',
+            'Does not validate if tools will actually work - just shows availability',
+            'Tool names must be used exactly as returned',
+            'Does not show tool parameters - use tools_documentation for details'
+        ],
+        relatedTools: ['n8n_diagnostic', 'n8n_health_check', 'tools_documentation']
+    }
+};
+//# sourceMappingURL=n8n-list-available-tools.js.map

package/dist/mcp/tool-docs/system/n8n-list-available-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8n-list-available-tools.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/n8n-list-available-tools.ts"],"names":[],"mappings":";;;AAEa,QAAA,wBAAwB,GAAsB;IACzD,IAAI,EAAE,0BAA0B;IAChC,QAAQ,EAAE,QAAQ;IAClB,UAAU,EAAE;QACV,WAAW,EAAE,gEAAgE;QAC7E,aAAa,EAAE,EAAE;QACjB,OAAO,EAAE,8BAA8B;QACvC,WAAW,EAAE,oCAAoC;QACjD,IAAI,EAAE;YACJ,2DAA2D;YAC3D,4DAA4D;YAC5D,oEAAoE;SACrE;KACF;IACD,IAAI,EAAE;QACJ,WAAW,EAAE;;;;;;;;;;;;uDAYsC;QACnD,UAAU,EAAE,EAAE;QACd,OAAO,EAAE;;;;;;;;+CAQkC;QAC3C,QAAQ,EAAE;YACR,yDAAyD;YACzD,wKAAwK;YACxK,+IAA+I;SAChJ;QACD,QAAQ,EAAE;YACR,mDAAmD;YACnD,oDAAoD;YACpD,4CAA4C;YAC5C,gDAAgD;YAChD,uDAAuD;SACxD;QACD,WAAW,EAAE;;;;wBAIO;QACpB,aAAa,EAAE;YACb,8DAA8D;YAC9D,uDAAuD;YACvD,uDAAuD;YACvD,sDAAsD;YACtD,4DAA4D;SAC7D;QACD,QAAQ,EAAE;YACR,+DAA+D;YAC/D,yEAAyE;YACzE,6CAA6C;YAC7C,qEAAqE;SACtE;QACD,YAAY,EAAE,CAAC,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,CAAC;KAC5E;CACF,CAAC"}

package/dist/mcp/tool-docs/system/tools-documentation.d.ts

@@ -0,0 +1,3 @@
+import { ToolDocumentation } from '../types';
+export declare const toolsDocumentationDoc: ToolDocumentation;
+//# sourceMappingURL=tools-documentation.d.ts.map

package/dist/mcp/tool-docs/system/tools-documentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-documentation.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/tools-documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,qBAAqB,EAAE,iBA4DnC,CAAC"}

package/dist/mcp/tool-docs/system/tools-documentation.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolsDocumentationDoc = void 0;
+exports.toolsDocumentationDoc = {
+    name: 'tools_documentation',
+    category: 'system',
+    essentials: {
+        description: 'The meta-documentation tool. Returns documentation for any MCP tool, including itself. Call without parameters for a comprehensive overview of all available tools. This is your starting point for discovering n8n MCP capabilities.',
+        keyParameters: ['topic', 'depth'],
+        example: 'tools_documentation({topic: "search_nodes"})',
+        performance: 'Instant (static content)',
+        tips: [
+            'Call without parameters first to see all tools',
+            'Can document itself: tools_documentation({topic: "tools_documentation"})',
+            'Use depth:"full" for comprehensive details'
+        ]
+    },
+    full: {
+        description: 'The self-referential documentation system for all MCP tools. This tool can document any other tool, including itself. It\'s the primary discovery mechanism for understanding what tools are available and how to use them. Returns utilitarian documentation optimized for AI agent consumption.',
+        parameters: {
+            topic: { type: 'string', description: 'Tool name (e.g., "search_nodes"), special topic ("javascript_code_node_guide", "python_code_node_guide"), or "overview". Leave empty for quick reference.', required: false },
+            depth: { type: 'string', description: 'Level of detail: "essentials" (default, concise) or "full" (comprehensive with examples)', required: false }
+        },
+        returns: 'Markdown-formatted documentation tailored for the requested tool and depth. For essentials: key info, parameters, example, tips. For full: complete details, all examples, use cases, best practices.',
+        examples: [
+            '// Get started - see all available tools',
+            'tools_documentation()',
+            '',
+            '// Learn about a specific tool',
+            'tools_documentation({topic: "search_nodes"})',
+            '',
+            '// Get comprehensive details',
+            'tools_documentation({topic: "validate_workflow", depth: "full"})',
+            '',
+            '// Self-referential example - document this tool',
+            'tools_documentation({topic: "tools_documentation", depth: "full"})',
+            '',
+            '// Code node guides',
+            'tools_documentation({topic: "javascript_code_node_guide"})',
+            'tools_documentation({topic: "python_code_node_guide"})'
+        ],
+        useCases: [
+            'Initial discovery of available MCP tools',
+            'Learning how to use specific tools',
+            'Finding required and optional parameters',
+            'Getting working examples to copy',
+            'Understanding tool performance characteristics',
+            'Discovering related tools for workflows'
+        ],
+        performance: 'Instant - all documentation is pre-loaded in memory',
+        bestPractices: [
+            'Always start with tools_documentation() to see available tools',
+            'Use essentials for quick parameter reference during coding',
+            'Switch to full depth when debugging or learning new tools',
+            'Check Code node guides when working with Code nodes'
+        ],
+        pitfalls: [
+            'Tool names must match exactly - use the overview to find correct names',
+            'Not all internal functions are documented',
+            'Special topics (code guides) require exact names'
+        ],
+        relatedTools: ['n8n_health_check for verifying API connection', 'search_templates for workflow examples', 'search_nodes for finding nodes']
+    }
+};
+//# sourceMappingURL=tools-documentation.js.map

package/dist/mcp/tool-docs/system/tools-documentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-documentation.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/system/tools-documentation.ts"],"names":[],"mappings":";;;AAEa,QAAA,qBAAqB,GAAsB;IACtD,IAAI,EAAE,qBAAqB;IAC3B,QAAQ,EAAE,QAAQ;IAClB,UAAU,EAAE;QACV,WAAW,EAAE,uOAAuO;QACpP,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC;QACjC,OAAO,EAAE,8CAA8C;QACvD,WAAW,EAAE,0BAA0B;QACvC,IAAI,EAAE;YACJ,gDAAgD;YAChD,0EAA0E;YAC1E,4CAA4C;SAC7C;KACF;IACD,IAAI,EAAE;QACJ,WAAW,EAAE,mSAAmS;QAChT,UAAU,EAAE;YACV,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,2JAA2J,EAAE,QAAQ,EAAE,KAAK,EAAE;YACpN,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,0FAA0F,EAAE,QAAQ,EAAE,KAAK,EAAE;SACpJ;QACD,OAAO,EAAE,uMAAuM;QAChN,QAAQ,EAAE;YACR,0CAA0C;YAC1C,uBAAuB;YACvB,EAAE;YACF,gCAAgC;YAChC,8CAA8C;YAC9C,EAAE;YACF,8BAA8B;YAC9B,kEAAkE;YAClE,EAAE;YACF,kDAAkD;YAClD,oEAAoE;YACpE,EAAE;YACF,qBAAqB;YACrB,4DAA4D;YAC5D,wDAAwD;SACzD;QACD,QAAQ,EAAE;YACR,0CAA0C;YAC1C,oCAAoC;YACpC,0CAA0C;YAC1C,kCAAkC;YAClC,gDAAgD;YAChD,yCAAyC;SAC1C;QACD,WAAW,EAAE,qDAAqD;QAClE,aAAa,EAAE;YACb,gEAAgE;YAChE,4DAA4D;YAC5D,2DAA2D;YAC3D,qDAAqD;SACtD;QACD,QAAQ,EAAE;YACR,wEAAwE;YACxE,2CAA2C;YAC3C,kDAAkD;SACnD;QACD,YAAY,EAAE,CAAC,+CAA+C,EAAE,wCAAwC,EAAE,gCAAgC,CAAC;KAC5I;CACF,CAAC"}

package/dist/mcp/tool-docs/templates/get-template.d.ts

@@ -0,0 +1,3 @@
+import { ToolDocumentation } from '../types';
+export declare const getTemplateDoc: ToolDocumentation;
+//# sourceMappingURL=get-template.d.ts.map

package/dist/mcp/tool-docs/templates/get-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-template.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/templates/get-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,cAAc,EAAE,iBA+E5B,CAAC"}

package/dist/mcp/tool-docs/templates/get-template.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateDoc = void 0;
+exports.getTemplateDoc = {
+    name: 'get_template',
+    category: 'templates',
+    essentials: {
+        description: 'Get workflow template by ID with configurable detail level. Ready to import. IDs from search_templates.',
+        keyParameters: ['templateId', 'mode'],
+        example: 'get_template({templateId: 1234, mode: "full"})',
+        performance: 'Fast (<100ms) - single database lookup',
+        tips: [
+            'Get template IDs from search_templates first',
+            'Use mode="nodes_only" for quick overview, "structure" for topology, "full" for import',
+            'Returns complete workflow JSON ready for import into n8n'
+        ]
+    },
+    full: {
+        description: `Retrieves the complete workflow JSON for a specific template by its ID. The returned workflow can be directly imported into n8n through the UI or API. This tool fetches pre-built workflows from the community template library containing 2,700+ curated workflows.`,
+        parameters: {
+            templateId: {
+                type: 'number',
+                required: true,
+                description: 'The numeric ID of the template to retrieve. Get IDs from search_templates'
+            },
+            mode: {
+                type: 'string',
+                required: false,
+                description: 'Response detail level: "nodes_only" (minimal - just node list), "structure" (nodes + connections), "full" (complete workflow JSON, default)',
+                default: 'full',
+                enum: ['nodes_only', 'structure', 'full']
+            }
+        },
+        returns: `Returns an object containing:
+- template: Complete template information including workflow JSON
+  - id: Template ID
+  - name: Template name
+  - description: What the workflow does
+  - author: Creator information (name, username, verified status)
+  - nodes: Array of node types used
+  - views: Number of times viewed
+  - created: Creation date
+  - url: Link to template on n8n.io
+  - workflow: Complete workflow JSON with structure:
+    - nodes: Array of node objects (id, name, type, typeVersion, position, parameters)
+    - connections: Object mapping source node names to targets
+    - settings: Workflow configuration (timezone, error handling, etc.)
+- usage: Instructions for using the workflow`,
+        examples: [
+            'get_template({templateId: 1234}) - Get complete workflow (default mode="full")',
+            'get_template({templateId: 1234, mode: "nodes_only"}) - Get just the node list',
+            'get_template({templateId: 1234, mode: "structure"}) - Get nodes and connections',
+            'get_template({templateId: 5678, mode: "full"}) - Get complete workflow JSON for import'
+        ],
+        useCases: [
+            'Download workflows for direct import into n8n',
+            'Study workflow patterns and best practices',
+            'Get complete workflow JSON for customization',
+            'Clone popular workflows for your use case',
+            'Learn how complex automations are built'
+        ],
+        performance: `Fast performance with single database lookup:
+- Query time: <10ms for template retrieval
+- Workflow JSON parsing: <50ms
+- Total response time: <100ms
+- No network calls (uses local cache)`,
+        bestPractices: [
+            'Always check if template exists before attempting modifications',
+            'Review workflow nodes before importing to ensure compatibility',
+            'Save template JSON locally if planning multiple customizations',
+            'Check template creation date for most recent patterns',
+            'Verify all required credentials are configured before import'
+        ],
+        pitfalls: [
+            'Template IDs change when database is refreshed',
+            'Some templates may use deprecated node versions',
+            'Credentials in templates are placeholders - configure your own',
+            'Not all templates work with all n8n versions',
+            'Template may reference external services you don\'t have access to'
+        ],
+        relatedTools: ['search_templates', 'n8n_create_workflow']
+    }
+};
+//# sourceMappingURL=get-template.js.map

package/dist/mcp/tool-docs/templates/get-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-template.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/templates/get-template.ts"],"names":[],"mappings":";;;AAEa,QAAA,cAAc,GAAsB;IAC/C,IAAI,EAAE,cAAc;IACpB,QAAQ,EAAE,WAAW;IACrB,UAAU,EAAE;QACV,WAAW,EAAE,yGAAyG;QACtH,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC;QACrC,OAAO,EAAE,gDAAgD;QACzD,WAAW,EAAE,wCAAwC;QACrD,IAAI,EAAE;YACJ,8CAA8C;YAC9C,uFAAuF;YACvF,0DAA0D;SAC3D;KACF;IACD,IAAI,EAAE;QACJ,WAAW,EAAE,uQAAuQ;QACpR,UAAU,EAAE;YACV,UAAU,EAAE;gBACV,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,2EAA2E;aACzF;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,KAAK;gBACf,WAAW,EAAE,6IAA6I;gBAC1J,OAAO,EAAE,MAAM;gBACf,IAAI,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,MAAM,CAAC;aAC1C;SACF;QACD,OAAO,EAAE;;;;;;;;;;;;;;6CAcgC;QACzC,QAAQ,EAAE;YACR,gFAAgF;YAChF,+EAA+E;YAC/E,iFAAiF;YACjF,wFAAwF;SACzF;QACD,QAAQ,EAAE;YACR,+CAA+C;YAC/C,4CAA4C;YAC5C,8CAA8C;YAC9C,2CAA2C;YAC3C,yCAAyC;SAC1C;QACD,WAAW,EAAE;;;;sCAIqB;QAClC,aAAa,EAAE;YACb,iEAAiE;YACjE,gEAAgE;YAChE,gEAAgE;YAChE,uDAAuD;YACvD,8DAA8D;SAC/D;QACD,QAAQ,EAAE;YACR,gDAAgD;YAChD,iDAAiD;YACjD,gEAAgE;YAChE,8CAA8C;YAC9C,oEAAoE;SACrE;QACD,YAAY,EAAE,CAAC,kBAAkB,EAAE,qBAAqB,CAAC;KAC1D;CACF,CAAC"}

package/dist/mcp/tool-docs/templates/index.d.ts

@@ -0,0 +1,3 @@
+export { getTemplateDoc } from './get-template';
+export { searchTemplatesDoc } from './search-templates';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/tool-docs/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/mcp/tool-docs/templates/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchTemplatesDoc = exports.getTemplateDoc = void 0;
+var get_template_1 = require("./get-template");
+Object.defineProperty(exports, "getTemplateDoc", { enumerable: true, get: function () { return get_template_1.getTemplateDoc; } });
+var search_templates_1 = require("./search-templates");
+Object.defineProperty(exports, "searchTemplatesDoc", { enumerable: true, get: function () { return search_templates_1.searchTemplatesDoc; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/tool-docs/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp/tool-docs/templates/index.ts"],"names":[],"mappings":";;;AAAA,+CAAgD;AAAvC,8GAAA,cAAc,OAAA;AACvB,uDAAwD;AAA/C,sHAAA,kBAAkB,OAAA"}

package/dist/mcp/tool-docs/templates/search-templates.d.ts

@@ -0,0 +1,3 @@
+import { ToolDocumentation } from '../types';
+export declare const searchTemplatesDoc: ToolDocumentation;
+//# sourceMappingURL=search-templates.d.ts.map