nodestorm-mcp 0.1.0 → 0.1.2

package/dist/tools/docs.js

@@ -0,0 +1,51 @@
+/**
+ * Docs tool definitions for the docs endpoints
+ * NodeStorm product documentation — node behavior, workflow mechanics, guides.
+ * These wrap the backend's v1 docs endpoints via NodeStormClient.
+ */
+export const DOCS_TOOL_DEFINITIONS = [
+    {
+        name: 'list_docs',
+        description: 'List NodeStorm product documentation pages — node behavior, workflow mechanics, guides. ' +
+            'Returns slug, title, category, and description for each page. Pass `category` to filter.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                category: {
+                    type: 'string',
+                    description: "Filter to a single category (e.g., 'node', 'guide', 'help')",
+                },
+            },
+        },
+    },
+    {
+        name: 'get_doc',
+        description: 'Get a NodeStorm documentation page by slug, including its full markdown body. ' +
+            'Use list_docs or search_docs to find slugs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: {
+                    type: 'string',
+                    description: 'Page slug (from list_docs or search_docs results)',
+                },
+            },
+            required: ['slug'],
+        },
+    },
+    {
+        name: 'search_docs',
+        description: 'Search NodeStorm product documentation using semantic (meaning-based) search. ' +
+            'Returns matching content chunks ranked by relevance to the query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Natural language search query',
+                },
+            },
+            required: ['query'],
+        },
+    },
+];

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "nodestorm-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "MCP server for NodeStorm workflow automation",
   "type": "module",
   "bin": {
-    "nodestorm-mcp": "./dist/index.js"
+    "nodestorm-mcp": "dist/index.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,7 +12,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && cp src/workflow-guide.md dist/",
+    "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "test": "vitest run",
@@ -31,7 +31,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nodestorm/nodestorm-mcp"
+    "url": "git+https://github.com/nodestorm/nodestorm-mcp.git"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0"

package/dist/tools/describe.d.ts

@@ -1,18 +0,0 @@
-/**
- * Node definitions for the describe_nodes tool
- * These are bundled statically to avoid API calls
- */
-export interface NodeDefinition {
-    type: string;
-    description: string;
-    category: string;
-    config_schema: Record<string, any>;
-    handles: {
-        inputs: string[];
-        outputs: string[];
-    };
-}
-/**
- * Get node definitions, optionally filtered by type
- */
-export declare function getNodeDefinitions(types?: string[]): NodeDefinition[];

package/dist/tools/describe.js

@@ -1,284 +0,0 @@
-/**
- * Node definitions for the describe_nodes tool
- * These are bundled statically to avoid API calls
- */
-// Static node definitions
-const NODE_DEFINITIONS = [
-    {
-        type: 'text',
-        description: 'Provide static text content to the workflow',
-        category: 'Data',
-        config_schema: {
-            input: { type: 'string', description: 'The static text content' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'list',
-        description: 'Extract list items using LLM or enter items manually',
-        category: 'Data',
-        config_schema: {
-            mode: { type: 'string', enum: ['extract', 'manual'], description: 'Mode of operation' },
-            input: { type: 'string', description: 'Manual items (one per line) or extraction prompt' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output', 'each'],
-        },
-    },
-    {
-        type: 'table',
-        description: 'Store and manipulate tabular data with rows and columns',
-        category: 'Data',
-        config_schema: {
-            columns: { type: 'array', description: 'Column definitions' },
-            rows: { type: 'array', description: 'Row data' },
-            storage_mode: { type: 'string', enum: ['inline', 'file'], description: 'Where to store data' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output', 'each'],
-        },
-    },
-    {
-        type: 'file',
-        description: 'Read from or write to persistent user files',
-        category: 'Data',
-        config_schema: {
-            operation: { type: 'string', enum: ['read', 'write', 'append'], description: 'File operation' },
-            file_id: { type: 'string', description: 'User file ID' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'search',
-        description: 'Search the web using Google and return results',
-        category: 'Web',
-        config_schema: {
-            input: { type: 'string', description: 'Search query' },
-            maxResults: { type: 'number', description: 'Maximum results (default: 5)' },
-            useLlmCleaning: { type: 'boolean', description: 'Use LLM to clean/summarize results' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'scraper',
-        description: 'Scrape web pages and extract content',
-        category: 'Web',
-        config_schema: {
-            input: { type: 'string', description: 'URL to scrape' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'prompt',
-        description: 'Process text using an LLM with custom prompts',
-        category: 'AI',
-        config_schema: {
-            input: { type: 'string', description: 'Prompt/instructions for the LLM' },
-            modelConfig: {
-                type: 'object',
-                description: 'LLM configuration',
-                properties: {
-                    provider: { type: 'string', enum: ['openai', 'anthropic', 'google'] },
-                    chat_model: { type: 'string', description: 'Model ID' },
-                    systemMessage: { type: 'string', description: 'System prompt' },
-                    temperature: { type: 'number', description: '0-2' },
-                    maxTokens: { type: 'number', description: 'Max response tokens' },
-                },
-            },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'boolean',
-        description: 'Make a yes/no decision using LLM',
-        category: 'AI',
-        config_schema: {
-            input: { type: 'string', description: 'Question to answer (yes/no)' },
-            modelConfig: { type: 'object', description: 'LLM configuration' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['true', 'false'],
-        },
-    },
-    {
-        type: 'json',
-        description: 'Extract structured JSON data using LLM',
-        category: 'AI',
-        config_schema: {
-            input: { type: 'string', description: 'Extraction instructions' },
-            schema: { type: 'object', description: 'JSON schema for output' },
-            modelConfig: { type: 'object', description: 'LLM configuration' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'switch',
-        description: 'Route to different paths based on conditions',
-        category: 'Control',
-        config_schema: {
-            condition_type: { type: 'string', enum: ['llm', 'regex', 'contains', 'equals'] },
-            cases: { type: 'array', description: 'List of case definitions' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['case-*'], // Dynamic based on cases
-        },
-    },
-    {
-        type: 'wait',
-        description: 'Pause execution for a specified time',
-        category: 'Control',
-        config_schema: {
-            delay_type: { type: 'string', enum: ['seconds', 'minutes', 'hours', 'until'] },
-            delay_amount: { type: 'number', description: 'Duration (for seconds/minutes/hours)' },
-            until_time: { type: 'string', description: 'ISO timestamp (for until)' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'aggregate',
-        description: 'Collect results from iteration into a single array',
-        category: 'Control',
-        config_schema: {},
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'http_request',
-        description: 'Make HTTP requests to external APIs',
-        category: 'Actions',
-        config_schema: {
-            url: { type: 'string', description: 'Request URL (required)' },
-            method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] },
-            headers: { type: 'object', description: 'Request headers' },
-            body: { type: 'string', description: 'Request body' },
-            credential_id: { type: 'string', description: 'API credential ID' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'email',
-        description: 'Send email to the authenticated user',
-        category: 'Actions',
-        config_schema: {
-            subject: { type: 'string', description: 'Email subject (required)' },
-            body: { type: 'string', description: 'Email body (required)' },
-            format: { type: 'string', enum: ['plain', 'html'] },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'google_drive',
-        description: 'Manage files and folders in Google Drive',
-        category: 'Integrations',
-        config_schema: {
-            operation: {
-                type: 'string',
-                enum: ['list_files', 'get_metadata', 'download_file', 'upload_file', 'update_file', 'create_folder', 'copy_file', 'move_file', 'delete_file', 'search_files'],
-            },
-            file_id: { type: 'string', description: 'File/folder ID' },
-            folder_id: { type: 'string', description: 'Parent folder ID' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'transcription',
-        description: 'Transcribe audio to text',
-        category: 'Media',
-        config_schema: {
-            audio_source: { type: 'string', enum: ['url', 'content'] },
-            provider: { type: 'string', enum: ['openai', 'google'] },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'image_generation',
-        description: 'Generate images using AI (DALL-E)',
-        category: 'Media',
-        config_schema: {
-            provider: { type: 'string', enum: ['openai'] },
-            operation: { type: 'string', enum: ['generate', 'edit', 'variation'] },
-            prompt: { type: 'string', description: 'Image prompt' },
-            size: { type: 'string', enum: ['256x256', '512x512', '1024x1024', '1024x1792', '1792x1024'] },
-            quality: { type: 'string', enum: ['standard', 'hd'] },
-            style: { type: 'string', enum: ['vivid', 'natural'] },
-            count: { type: 'number', description: 'Number of images (1-4)' },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'keyword_data',
-        description: 'Look up SEO keyword data (search volume, CPC, competition) via Keywords Everywhere API',
-        category: 'Web',
-        config_schema: {
-            input: { type: 'string', description: 'Keywords (one per line) or extraction prompt' },
-            country: { type: 'string', description: "Country code (e.g. 'us')" },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: ['output'],
-        },
-    },
-    {
-        type: 'result',
-        description: 'Render flow output on the canvas. LLM-formats the upstream value into the chosen target (~$0.01, ~4s per render).',
-        category: 'Output',
-        config_schema: {
-            format: { type: 'string', enum: ['html', 'markdown', 'plain'], description: "Output target. Default 'html'." },
-        },
-        handles: {
-            inputs: ['input'],
-            outputs: [],
-        },
-    },
-];
-/**
- * Get node definitions, optionally filtered by type
- */
-export function getNodeDefinitions(types) {
-    if (!types || types.length === 0) {
-        return NODE_DEFINITIONS;
-    }
-    return NODE_DEFINITIONS.filter((node) => types.includes(node.type));
-}