neuron-inspector 0.7.0 → 0.8.0

package/dist/collections/tools.js

@@ -1,1276 +0,0 @@
-import { readFile } from "node:fs/promises";
-import * as YAML from "yaml";
-import { slugify } from "./store.js";
-import { executeEndpoint, executeFolder, executeCollection, executeScenario } from "./executor.js";
-import { fromPostmanV21, toPostmanV21 } from "./postman.js";
-export function buildCollectionTools() {
-    return [
-        {
-            name: "neuron_api_list_collections",
-            description: "List all API collections (global + project-local) with folder, endpoint, environment, and scenario counts.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "neuron_api_get_collection",
-            description: "Get the full structure of an API collection: folders, endpoints, environments, and scenarios.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: {
-                        type: "string",
-                        description: "Collection id (filename stem, e.g. 'neuron-api')",
-                    },
-                },
-                required: ["collection"],
-            },
-        },
-        {
-            name: "neuron_api_create_collection",
-            description: "Create a new empty API collection. Returns error if a collection with the same slug already exists.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    name: {
-                        type: "string",
-                        description: "Human-readable collection name (e.g. 'Neuron API')",
-                    },
-                    description: {
-                        type: "string",
-                        description: "Optional description of the collection",
-                    },
-                    base_url: {
-                        type: "string",
-                        description: "Optional default base URL. If provided, creates a 'default' environment with this URL.",
-                    },
-                    location: {
-                        type: "string",
-                        enum: ["global", "project"],
-                        description: "Where to store: 'global' (~/.neuron/collections/) or 'project' (.neuron/collections/ in cwd). Default: global.",
-                    },
-                },
-                required: ["name"],
-            },
-        },
-        {
-            name: "neuron_api_delete_collection",
-            description: "Delete an API collection file.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: {
-                        type: "string",
-                        description: "Collection id to delete",
-                    },
-                },
-                required: ["collection"],
-            },
-        },
-        {
-            name: "neuron_api_upsert_endpoint",
-            description: "Add or update an endpoint in a collection folder. Creates the folder if it does not exist. " +
-                "Matches existing endpoints by method + path within the folder. If a match is found, the endpoint is updated; otherwise it is appended. " +
-                "If 'name' is omitted, it is auto-generated from the method and path.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: {
-                        type: "string",
-                        description: "Collection id",
-                    },
-                    folder: {
-                        type: "string",
-                        description: "Folder name (e.g. 'auth', 'orders'). Will be slugified as the YAML key.",
-                    },
-                    method: {
-                        type: "string",
-                        description: "HTTP method (GET, POST, PUT, PATCH, DELETE)",
-                    },
-                    path: {
-                        type: "string",
-                        description: "Endpoint path (e.g. '/api/v1/bots'). May contain {{variables}}.",
-                    },
-                    name: {
-                        type: "string",
-                        description: "Human-readable name. Auto-generated from method+path if omitted.",
-                    },
-                    description: {
-                        type: "string",
-                        description: "Endpoint description",
-                    },
-                    headers: {
-                        type: "object",
-                        description: "Request-level header overrides",
-                    },
-                    body: {
-                        description: "Sample request body (any JSON value)",
-                    },
-                    tests: {
-                        type: "array",
-                        description: "Test assertions, e.g. [{ check: 'status', expect: 200 }, { check: 'body.id', op: 'exists' }]",
-                        items: {
-                            type: "object",
-                            properties: {
-                                check: { type: "string" },
-                                op: { type: "string" },
-                                expect: {},
-                            },
-                            required: ["check"],
-                        },
-                    },
-                    extract: {
-                        type: "object",
-                        description: "Variables to extract from the response, e.g. { bot_id: 'body.id' }",
-                    },
-                    body_mode: {
-                        type: "string",
-                        enum: ["json", "text", "form-data", "urlencoded"],
-                        description: "Body encoding mode. Default: json",
-                    },
-                    cookies: {
-                        type: "object",
-                        description: "Request cookies as key-value pairs, merged into Cookie header on run",
-                    },
-                    variables: {
-                        type: "object",
-                        description: "Request-level variable overrides (key-value pairs)",
-                    },
-                    auth: {
-                        type: "object",
-                        description: "Auth config: { type: 'bearer'|'basic'|'api-key'|'none', token?, username?, password?, header?, value? }",
-                        properties: {
-                            type: { type: "string", enum: ["bearer", "basic", "api-key", "none"] },
-                            token: { type: "string" },
-                            username: { type: "string" },
-                            password: { type: "string" },
-                            header: { type: "string" },
-                            value: { type: "string" },
-                        },
-                        required: ["type"],
-                    },
-                    pre_request: {
-                        type: "object",
-                        description: "Pre-request script: { set?: {var: value}, extract?: {var: expression} }",
-                        properties: {
-                            set: { type: "object" },
-                            extract: { type: "object" },
-                        },
-                    },
-                    post_response: {
-                        type: "object",
-                        description: "Post-response script: { set?: {var: value}, extract?: {var: expression} }",
-                        properties: {
-                            set: { type: "object" },
-                            extract: { type: "object" },
-                        },
-                    },
-                    tags: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Tags for filtering/querying",
-                    },
-                    timeout_ms: {
-                        type: "number",
-                        description: "Per-endpoint timeout override (ms)",
-                    },
-                    settings: {
-                        type: "object",
-                        description: "Request settings: timeout, redirects, SSL, URL encoding",
-                        properties: {
-                            timeout_ms: { type: "number" },
-                            follow_redirects: { type: "boolean" },
-                            max_redirects: { type: "number" },
-                            verify_ssl: { type: "boolean" },
-                            follow_original_method: { type: "boolean", description: "Redirect with original HTTP method instead of GET" },
-                            follow_authorization: { type: "boolean", description: "Retain Authorization header on cross-host redirects" },
-                            remove_referer: { type: "boolean", description: "Remove Referer header on redirect" },
-                            encode_url: { type: "boolean", description: "Encode URL automatically" },
-                        },
-                    },
-                },
-                required: ["collection", "folder", "method", "path"],
-            },
-        },
-        {
-            name: "neuron_api_remove_endpoint",
-            description: "Remove an endpoint from a collection folder by method + path.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: {
-                        type: "string",
-                        description: "Collection id",
-                    },
-                    folder: {
-                        type: "string",
-                        description: "Folder name",
-                    },
-                    method: {
-                        type: "string",
-                        description: "HTTP method of the endpoint to remove",
-                    },
-                    path: {
-                        type: "string",
-                        description: "Path of the endpoint to remove",
-                    },
-                },
-                required: ["collection", "folder", "method", "path"],
-            },
-        },
-        {
-            name: "neuron_api_move_endpoint",
-            description: "Move an endpoint from one folder to another.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: {
-                        type: "string",
-                        description: "Collection id",
-                    },
-                    from_folder: {
-                        type: "string",
-                        description: "Source folder name",
-                    },
-                    to_folder: {
-                        type: "string",
-                        description: "Destination folder name (created if absent)",
-                    },
-                    method: {
-                        type: "string",
-                        description: "HTTP method of the endpoint to move",
-                    },
-                    path: {
-                        type: "string",
-                        description: "Path of the endpoint to move",
-                    },
-                },
-                required: ["collection", "from_folder", "to_folder", "method", "path"],
-            },
-        },
-        // ── Environment management ───────────────────────────────
-        {
-            name: "neuron_api_set_env",
-            description: "Create or update an environment in a collection with base_url, variables, and headers.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    name: { type: "string", description: "Environment name (e.g. 'staging', 'production')" },
-                    base_url: { type: "string", description: "Base URL for this environment" },
-                    variables: { type: "object", description: "Environment variables (key-value pairs)" },
-                    headers: { type: "object", description: "Environment-specific header overrides" },
-                    timeout_ms: { type: "number", description: "Environment-specific timeout" },
-                },
-                required: ["collection", "name", "base_url"],
-            },
-        },
-        {
-            name: "neuron_api_remove_env",
-            description: "Remove an environment from a collection.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    name: { type: "string", description: "Environment name to remove" },
-                },
-                required: ["collection", "name"],
-            },
-        },
-        {
-            name: "neuron_api_list_envs",
-            description: "List all environments for a collection with their base URLs and variable counts.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                },
-                required: ["collection"],
-            },
-        },
-        {
-            name: "neuron_api_switch_env",
-            description: "Set the active environment for a collection. Persisted to the collection file so subsequent runs use it by default.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    name: { type: "string", description: "Environment name to activate" },
-                },
-                required: ["collection", "name"],
-            },
-        },
-        // ── Collection metadata ─────────────────────────────────
-        {
-            name: "neuron_api_update_collection",
-            description: "Update a collection's name, description, or version.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    name: { type: "string", description: "New collection name" },
-                    description: { type: "string", description: "New description (empty string to clear)" },
-                    version: { type: "string", description: "New version string" },
-                },
-                required: ["collection"],
-            },
-        },
-        // ── Defaults management ───────────────────────────────────
-        {
-            name: "neuron_api_set_defaults",
-            description: "Set or update collection-level defaults. Merges with existing defaults. " +
-                "Pass null for auth to clear it. Omit fields to leave them unchanged.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    headers: { type: "object", description: "Default headers (key-value pairs)" },
-                    variables: { type: "object", description: "Default variables (key-value pairs)" },
-                    timeout_ms: { type: "number", description: "Default timeout (ms)" },
-                    auth: {
-                        type: "object",
-                        description: "Default auth: { type: 'bearer'|'basic'|'api-key'|'none', token?, username?, password?, header?, value? }. Pass null to clear.",
-                        properties: {
-                            type: { type: "string", enum: ["bearer", "basic", "api-key", "none"] },
-                            token: { type: "string" },
-                            username: { type: "string" },
-                            password: { type: "string" },
-                            header: { type: "string" },
-                            value: { type: "string" },
-                        },
-                    },
-                    pre_request: {
-                        type: "object",
-                        description: "Pre-request script that runs before every endpoint. { code?: string, set?: {}, extract?: {} }. Pass null to clear.",
-                        properties: {
-                            code: { type: "string" },
-                            set: { type: "object" },
-                            extract: { type: "object" },
-                        },
-                    },
-                    post_response: {
-                        type: "object",
-                        description: "Post-response script that runs after every endpoint. { code?: string, set?: {}, extract?: {} }. Pass null to clear.",
-                        properties: {
-                            code: { type: "string" },
-                            set: { type: "object" },
-                            extract: { type: "object" },
-                        },
-                    },
-                },
-                required: ["collection"],
-            },
-        },
-        // ── Folder management ─────────────────────────────────────
-        {
-            name: "neuron_api_create_folder",
-            description: "Create a new folder in a collection with optional description, headers, variables, and auth.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    name: { type: "string", description: "Folder name" },
-                    description: { type: "string", description: "Folder description" },
-                    headers: { type: "object", description: "Folder-level default headers" },
-                    variables: { type: "object", description: "Folder-level default variables" },
-                    auth: {
-                        type: "object",
-                        description: "Folder-level auth config",
-                        properties: {
-                            type: { type: "string", enum: ["bearer", "basic", "api-key", "none"] },
-                            token: { type: "string" },
-                            username: { type: "string" },
-                            password: { type: "string" },
-                            header: { type: "string" },
-                            value: { type: "string" },
-                        },
-                    },
-                },
-                required: ["collection", "name"],
-            },
-        },
-        {
-            name: "neuron_api_update_folder",
-            description: "Update a folder's description, headers, variables, or auth. Pass null for auth to clear it.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    folder: { type: "string", description: "Folder name" },
-                    description: { type: "string", description: "New description (empty string to clear)" },
-                    headers: { type: "object", description: "New folder-level headers (replaces existing)" },
-                    variables: { type: "object", description: "New folder-level variables (replaces existing)" },
-                    auth: {
-                        type: "object",
-                        description: "New folder-level auth config. Pass null to clear.",
-                        properties: {
-                            type: { type: "string", enum: ["bearer", "basic", "api-key", "none"] },
-                            token: { type: "string" },
-                            username: { type: "string" },
-                            password: { type: "string" },
-                            header: { type: "string" },
-                            value: { type: "string" },
-                        },
-                    },
-                },
-                required: ["collection", "folder"],
-            },
-        },
-        {
-            name: "neuron_api_delete_folder",
-            description: "Delete a folder and all its endpoints from a collection.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    folder: { type: "string", description: "Folder name to delete" },
-                },
-                required: ["collection", "folder"],
-            },
-        },
-        {
-            name: "neuron_api_list_folders",
-            description: "List all folders in a collection with endpoint counts, descriptions, and whether they have custom headers/variables/auth.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                },
-                required: ["collection"],
-            },
-        },
-        // ── Scenario management ───────────────────────────────────
-        {
-            name: "neuron_api_create_scenario",
-            description: "Create a new scenario in a collection. Steps reference endpoints as 'folder/method path' (e.g. 'auth/POST /login').",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    name: { type: "string", description: "Scenario name" },
-                    description: { type: "string", description: "Scenario description" },
-                    steps: {
-                        type: "array",
-                        description: "Ordered steps. Each step has a 'ref' (folder/METHOD path) and optional overrides.",
-                        items: {
-                            type: "object",
-                            properties: {
-                                ref: { type: "string", description: "Endpoint reference: 'folder/METHOD path'" },
-                                overrides: {
-                                    type: "object",
-                                    description: "Per-step overrides for headers, body, tests, path, variables",
-                                    properties: {
-                                        headers: { type: "object" },
-                                        body: {},
-                                        tests: { type: "array" },
-                                        path: { type: "string" },
-                                        variables: { type: "object" },
-                                    },
-                                },
-                            },
-                            required: ["ref"],
-                        },
-                    },
-                },
-                required: ["collection", "name", "steps"],
-            },
-        },
-        {
-            name: "neuron_api_update_scenario",
-            description: "Update a scenario's description or steps.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    scenario: { type: "string", description: "Scenario name" },
-                    description: { type: "string", description: "New description" },
-                    steps: {
-                        type: "array",
-                        description: "New ordered steps (replaces existing)",
-                        items: {
-                            type: "object",
-                            properties: {
-                                ref: { type: "string" },
-                                overrides: { type: "object" },
-                            },
-                            required: ["ref"],
-                        },
-                    },
-                },
-                required: ["collection", "scenario"],
-            },
-        },
-        {
-            name: "neuron_api_delete_scenario",
-            description: "Delete a scenario from a collection.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    scenario: { type: "string", description: "Scenario name to delete" },
-                },
-                required: ["collection", "scenario"],
-            },
-        },
-        {
-            name: "neuron_api_list_scenarios",
-            description: "List all scenarios in a collection with their step counts and descriptions.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                },
-                required: ["collection"],
-            },
-        },
-        // ── Execution ────────────────────────────────────────────
-        {
-            name: "neuron_api_run",
-            description: "Run API endpoints against an environment. Three modes:\n" +
-                "  1. Single endpoint: provide collection + folder + method + path\n" +
-                "  2. Folder: provide collection + folder (runs all endpoints in the folder sequentially)\n" +
-                "  3. Collection: provide only collection (runs all folders, all endpoints)\n" +
-                "Returns status, headers, parsed body, timing, test assertion results, and extracted variables. " +
-                "Folder/collection runs continue on failure. Extracted variables carry between endpoints within a folder.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    folder: { type: "string", description: "Folder name (omit to run entire collection)" },
-                    method: { type: "string", description: "HTTP method (required for single-endpoint mode)" },
-                    path: { type: "string", description: "Endpoint path (required for single-endpoint mode)" },
-                    environment: { type: "string", description: "Environment name (defaults to active_environment)" },
-                    cookies: { type: "object", description: "Additional cookies for this run (merged with endpoint cookies)" },
-                    timeout_ms: { type: "number", description: "Override timeout (ms) for this run" },
-                    follow_redirects: { type: "boolean", description: "Override follow-redirects setting for this run" },
-                    max_redirects: { type: "number", description: "Override max redirects for this run" },
-                    verify_ssl: { type: "boolean", description: "Override SSL verification for this run" },
-                    follow_original_method: { type: "boolean", description: "Override: redirect with original HTTP method" },
-                    follow_authorization: { type: "boolean", description: "Override: retain Authorization on cross-host redirects" },
-                    remove_referer: { type: "boolean", description: "Override: remove Referer header on redirect" },
-                    encode_url: { type: "boolean", description: "Override: encode URL automatically" },
-                },
-                required: ["collection"],
-            },
-        },
-        {
-            name: "neuron_api_run_scenario",
-            description: "Run a named scenario: an ordered sequence of endpoint calls with variable chaining. " +
-                "Extracted variables from each step are available to subsequent steps via {{variable}} references. " +
-                "Execution halts on the first step that fails (HTTP error or assertion failure). " +
-                "Steps can include overrides for headers, body, tests, path, and variables.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    scenario: { type: "string", description: "Scenario name (key under 'scenarios' in the collection)" },
-                    environment: { type: "string", description: "Environment name (defaults to active_environment)" },
-                },
-                required: ["collection", "scenario"],
-            },
-        },
-        // ── Query and generation ─────────────────────────────────
-        {
-            name: "neuron_api_query",
-            description: "Search endpoints across all collections by method, path pattern, folder, tags, or free text. " +
-                "Returns matching endpoints with their collection and folder context. " +
-                "All filters are optional; omit all for a full listing.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Limit to a specific collection id" },
-                    method: { type: "string", description: "Filter by HTTP method (GET, POST, etc.)" },
-                    path: { type: "string", description: "Filter by path pattern (substring match, e.g. '/bots')" },
-                    folder: { type: "string", description: "Filter by folder name" },
-                    tags: { type: "array", items: { type: "string" }, description: "Filter by tags (any match)" },
-                    text: { type: "string", description: "Free-text search across endpoint names, descriptions, and paths" },
-                },
-            },
-        },
-        {
-            name: "neuron_api_generate_tests",
-            description: "Suggest test assertions for an endpoint based on its method, path, existing body, and common REST patterns. " +
-                "Returns a YAML-ready assertions array. Does not modify the collection.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    folder: { type: "string", description: "Folder name" },
-                    method: { type: "string", description: "HTTP method" },
-                    path: { type: "string", description: "Endpoint path" },
-                },
-                required: ["collection", "folder", "method", "path"],
-            },
-        },
-        // ── Import / Export ───────────────────────────────────────
-        {
-            name: "neuron_api_export_collection",
-            description: "Export a collection as YAML or Postman v2.1 JSON. Returns the file content as a string.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    collection: { type: "string", description: "Collection id" },
-                    format: {
-                        type: "string",
-                        enum: ["yaml", "postman"],
-                        description: "Export format: 'yaml' (default) or 'postman' (Postman v2.1 JSON)",
-                    },
-                },
-                required: ["collection"],
-            },
-        },
-        {
-            name: "neuron_api_import_collection",
-            description: "Import a collection from raw YAML or Postman v2.1 JSON content. Auto-detects format unless specified.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    content: { type: "string", description: "Raw file content (YAML or JSON)" },
-                    format: {
-                        type: "string",
-                        enum: ["yaml", "postman", "auto"],
-                        description: "Content format. 'auto' (default) detects from content.",
-                    },
-                    name: { type: "string", description: "Optional name override for the imported collection" },
-                    location: {
-                        type: "string",
-                        enum: ["global", "project"],
-                        description: "Where to store: 'global' (default) or 'project'",
-                    },
-                },
-                required: ["content"],
-            },
-        },
-        {
-            name: "neuron_api_import_file",
-            description: "Import a collection from a file path. Auto-detects format from extension and content.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    path: { type: "string", description: "Absolute file path to import" },
-                    name: { type: "string", description: "Optional name override" },
-                    location: {
-                        type: "string",
-                        enum: ["global", "project"],
-                        description: "Where to store: 'global' (default) or 'project'",
-                    },
-                },
-                required: ["path"],
-            },
-        },
-    ];
-}
-// ── Handler ─────────────────────────────────────────────────────
-export function buildCollectionHandler(store, httpExecutor, pipeline, assertionEvaluator, scriptRunner) {
-    return async function handleCollectionTool(name, args) {
-        switch (name) {
-            case "neuron_api_list_collections": {
-                return store.list();
-            }
-            case "neuron_api_get_collection": {
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                return result;
-            }
-            case "neuron_api_create_collection": {
-                const collName = args.name;
-                const id = slugify(collName);
-                if (!id)
-                    return { error: "Name produces an empty slug" };
-                const existing = await store.resolve(id);
-                if (existing) {
-                    return { error: `Collection '${id}' already exists at ${existing.path}` };
-                }
-                const location = args.location ?? "global";
-                const collection = {
-                    name: collName,
-                    version: "1.0.0",
-                };
-                if (args.description)
-                    collection.description = args.description;
-                if (args.base_url) {
-                    collection.environments = {
-                        default: { base_url: args.base_url },
-                    };
-                    collection.active_environment = "default";
-                }
-                collection.folders = {};
-                const path = await store.save(id, collection, location);
-                return { id, path, location };
-            }
-            case "neuron_api_delete_collection": {
-                const id = args.collection;
-                const deleted = await store.delete(id);
-                if (!deleted)
-                    return { error: `Collection '${id}' not found` };
-                return { deleted: true, id };
-            }
-            case "neuron_api_upsert_endpoint": {
-                const id = args.collection;
-                const folder = args.folder;
-                const { collection: _c, folder: _f, ...endpointFields } = args;
-                const result = await store.upsertEndpoint(id, folder, endpointFields);
-                return {
-                    action: result.action,
-                    collection: id,
-                    folder: slugify(folder),
-                    method: args.method.toUpperCase(),
-                    path: args.path,
-                };
-            }
-            case "neuron_api_remove_endpoint": {
-                const id = args.collection;
-                await store.removeEndpoint(id, args.folder, args.method, args.path);
-                return {
-                    removed: true,
-                    collection: id,
-                    folder: args.folder,
-                    method: args.method,
-                    path: args.path,
-                };
-            }
-            case "neuron_api_move_endpoint": {
-                const id = args.collection;
-                await store.moveEndpoint(id, args.from_folder, args.to_folder, args.method, args.path);
-                return {
-                    moved: true,
-                    collection: id,
-                    from: args.from_folder,
-                    to: slugify(args.to_folder),
-                    method: args.method,
-                    path: args.path,
-                };
-            }
-            // ── Environment management ─────────────────────────────
-            case "neuron_api_set_env": {
-                const id = args.collection;
-                const envName = args.name;
-                const env = { base_url: args.base_url };
-                if (args.variables)
-                    env.variables = args.variables;
-                if (args.headers)
-                    env.headers = args.headers;
-                if (args.timeout_ms)
-                    env.timeout_ms = args.timeout_ms;
-                await store.setEnvironment(id, envName, env);
-                return { set: true, collection: id, environment: slugify(envName) };
-            }
-            case "neuron_api_remove_env": {
-                const id = args.collection;
-                await store.removeEnvironment(id, args.name);
-                return { removed: true, collection: id, environment: args.name };
-            }
-            case "neuron_api_list_envs": {
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                const envs = result.collection.environments ?? {};
-                return {
-                    collection: id,
-                    active: result.collection.active_environment ?? null,
-                    environments: Object.entries(envs).map(([key, env]) => ({
-                        name: key,
-                        base_url: env.base_url,
-                        variable_count: env.variables ? Object.keys(env.variables).length : 0,
-                        has_headers: !!env.headers && Object.keys(env.headers).length > 0,
-                        timeout_ms: env.timeout_ms,
-                    })),
-                };
-            }
-            case "neuron_api_switch_env": {
-                const id = args.collection;
-                await store.switchEnvironment(id, args.name);
-                return { switched: true, collection: id, active: slugify(args.name) };
-            }
-            // ── Collection metadata ──────────────────────────────
-            case "neuron_api_update_collection": {
-                const id = args.collection;
-                const updates = {};
-                if (args.name !== undefined)
-                    updates.name = args.name;
-                if (args.description !== undefined)
-                    updates.description = args.description;
-                if (args.version !== undefined)
-                    updates.version = args.version;
-                if (Object.keys(updates).length === 0)
-                    return { error: "No updates provided" };
-                await store.updateMetadata(id, updates);
-                return { updated: true, collection: id, ...updates };
-            }
-            // ── Defaults management ─────────────────────────────
-            case "neuron_api_set_defaults": {
-                const id = args.collection;
-                const { collection: _c, ...defaults } = args;
-                if (Object.keys(defaults).length === 0)
-                    return { error: "No defaults provided" };
-                await store.setDefaults(id, defaults);
-                return { set: true, collection: id, fields: Object.keys(defaults) };
-            }
-            // ── Folder management ───────────────────────────────
-            case "neuron_api_create_folder": {
-                const id = args.collection;
-                const folderName = args.name;
-                const meta = {};
-                if (args.description)
-                    meta.description = args.description;
-                if (args.headers)
-                    meta.headers = args.headers;
-                if (args.variables)
-                    meta.variables = args.variables;
-                if (args.auth)
-                    meta.auth = args.auth;
-                await store.createFolder(id, folderName, meta);
-                return { created: true, collection: id, folder: slugify(folderName) };
-            }
-            case "neuron_api_update_folder": {
-                const id = args.collection;
-                const folderName = args.folder;
-                const updates = {};
-                if (args.description !== undefined)
-                    updates.description = args.description;
-                if (args.headers !== undefined)
-                    updates.headers = args.headers;
-                if (args.variables !== undefined)
-                    updates.variables = args.variables;
-                if (args.auth !== undefined)
-                    updates.auth = args.auth;
-                if (Object.keys(updates).length === 0)
-                    return { error: "No updates provided" };
-                await store.updateFolder(id, folderName, updates);
-                return { updated: true, collection: id, folder: slugify(folderName), fields: Object.keys(updates) };
-            }
-            case "neuron_api_delete_folder": {
-                const id = args.collection;
-                await store.deleteFolder(id, args.folder);
-                return { deleted: true, collection: id, folder: args.folder };
-            }
-            case "neuron_api_list_folders": {
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                const folders = result.collection.folders ?? {};
-                return {
-                    collection: id,
-                    folders: Object.entries(folders).map(([key, f]) => ({
-                        name: key,
-                        endpoint_count: f.endpoints?.length ?? 0,
-                        description: f.description ?? null,
-                        has_headers: !!f.headers && Object.keys(f.headers).length > 0,
-                        has_variables: !!f.variables && Object.keys(f.variables).length > 0,
-                        has_auth: !!f.auth && f.auth.type !== "none",
-                    })),
-                };
-            }
-            // ── Scenario management ─────────────────────────────
-            case "neuron_api_create_scenario": {
-                const id = args.collection;
-                const scenarioName = args.name;
-                const scenario = {
-                    steps: args.steps,
-                };
-                if (args.description)
-                    scenario.description = args.description;
-                await store.createScenario(id, scenarioName, scenario);
-                return { created: true, collection: id, scenario: scenarioName, step_count: scenario.steps.length };
-            }
-            case "neuron_api_update_scenario": {
-                const id = args.collection;
-                const scenarioName = args.scenario;
-                const updates = {};
-                if (args.description !== undefined)
-                    updates.description = args.description;
-                if (args.steps !== undefined)
-                    updates.steps = args.steps;
-                if (Object.keys(updates).length === 0)
-                    return { error: "No updates provided" };
-                await store.updateScenario(id, scenarioName, updates);
-                return { updated: true, collection: id, scenario: scenarioName };
-            }
-            case "neuron_api_delete_scenario": {
-                const id = args.collection;
-                await store.deleteScenario(id, args.scenario);
-                return { deleted: true, collection: id, scenario: args.scenario };
-            }
-            case "neuron_api_list_scenarios": {
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                const scenarios = result.collection.scenarios ?? {};
-                return {
-                    collection: id,
-                    scenarios: Object.entries(scenarios).map(([key, s]) => ({
-                        name: key,
-                        description: s.description ?? null,
-                        step_count: s.steps?.length ?? 0,
-                    })),
-                };
-            }
-            // ── Execution ─────────────────────────────────────────
-            case "neuron_api_run": {
-                if (!httpExecutor || !pipeline || !assertionEvaluator) {
-                    return { error: "HTTP executor not configured" };
-                }
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                const { collection } = result;
-                // Resolve environment
-                const envName = args.environment ?? collection.active_environment;
-                if (!envName) {
-                    return { error: "No environment specified and no active_environment set on the collection" };
-                }
-                const environment = collection.environments?.[slugify(envName)];
-                if (!environment) {
-                    return { error: `Environment '${envName}' not found in collection '${id}'` };
-                }
-                const hasFolder = typeof args.folder === "string";
-                const hasEndpoint = typeof args.method === "string" && typeof args.path === "string";
-                // Mode 3: Collection-wide run (no folder specified)
-                if (!hasFolder) {
-                    return executeCollection({
-                        collectionId: id,
-                        collection,
-                        environment,
-                        httpExecutor,
-                        pipeline,
-                        assertionEvaluator,
-                        scriptRunner,
-                    });
-                }
-                const folderKey = slugify(args.folder);
-                const folder = collection.folders?.[folderKey];
-                if (!folder) {
-                    return { error: `Folder '${args.folder}' not found in collection '${id}'` };
-                }
-                // Mode 2: Folder run (folder but no method/path)
-                if (!hasEndpoint) {
-                    return executeFolder({
-                        folderKey,
-                        collection,
-                        environment,
-                        folder,
-                        httpExecutor,
-                        pipeline,
-                        assertionEvaluator,
-                        scriptRunner,
-                    });
-                }
-                // Mode 1: Single endpoint
-                const method = args.method.toUpperCase();
-                const foundEndpoint = folder.endpoints?.find((ep) => ep.method.toUpperCase() === method && ep.path === args.path);
-                if (!foundEndpoint) {
-                    return { error: `Endpoint ${method} ${args.path} not found in folder '${args.folder}'` };
-                }
-                // Apply per-run overrides
-                const endpoint = { ...foundEndpoint };
-                if (args.cookies || args.timeout_ms || args.follow_redirects !== undefined || args.max_redirects || args.verify_ssl !== undefined || args.follow_original_method !== undefined || args.follow_authorization !== undefined || args.remove_referer !== undefined || args.encode_url !== undefined) {
-                    if (args.cookies) {
-                        endpoint.cookies = { ...(endpoint.cookies ?? {}), ...args.cookies };
-                    }
-                    const runSettings = { ...(endpoint.settings ?? {}) };
-                    if (args.timeout_ms !== undefined)
-                        runSettings.timeout_ms = args.timeout_ms;
-                    if (args.follow_redirects !== undefined)
-                        runSettings.follow_redirects = args.follow_redirects;
-                    if (args.max_redirects !== undefined)
-                        runSettings.max_redirects = args.max_redirects;
-                    if (args.verify_ssl !== undefined)
-                        runSettings.verify_ssl = args.verify_ssl;
-                    if (args.follow_original_method !== undefined)
-                        runSettings.follow_original_method = args.follow_original_method;
-                    if (args.follow_authorization !== undefined)
-                        runSettings.follow_authorization = args.follow_authorization;
-                    if (args.remove_referer !== undefined)
-                        runSettings.remove_referer = args.remove_referer;
-                    if (args.encode_url !== undefined)
-                        runSettings.encode_url = args.encode_url;
-                    endpoint.settings = runSettings;
-                }
-                return executeEndpoint({
-                    collection,
-                    environment,
-                    folder,
-                    endpoint,
-                    httpExecutor,
-                    pipeline,
-                    assertionEvaluator,
-                    scriptRunner,
-                });
-            }
-            case "neuron_api_run_scenario": {
-                if (!httpExecutor || !pipeline || !assertionEvaluator) {
-                    return { error: "HTTP executor not configured" };
-                }
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                const { collection } = result;
-                // Resolve environment
-                const envName = args.environment ?? collection.active_environment;
-                if (!envName) {
-                    return { error: "No environment specified and no active_environment set on the collection" };
-                }
-                const environment = collection.environments?.[slugify(envName)];
-                if (!environment) {
-                    return { error: `Environment '${envName}' not found in collection '${id}'` };
-                }
-                // Find scenario
-                const scenarioKey = args.scenario;
-                const scenario = collection.scenarios?.[scenarioKey];
-                if (!scenario) {
-                    return { error: `Scenario '${scenarioKey}' not found in collection '${id}'` };
-                }
-                return executeScenario({
-                    scenarioKey,
-                    steps: scenario.steps,
-                    collectionId: id,
-                    collection,
-                    environment,
-                    httpExecutor,
-                    pipeline,
-                    assertionEvaluator,
-                    scriptRunner,
-                });
-            }
-            // ── Query and generation ─────────────────────────────
-            case "neuron_api_query": {
-                const collections = await store.list();
-                const targetIds = args.collection
-                    ? [args.collection]
-                    : collections.map((c) => c.id);
-                const results = [];
-                const methodFilter = args.method ? args.method.toUpperCase() : undefined;
-                const pathFilter = args.path;
-                const folderFilter = args.folder ? slugify(args.folder) : undefined;
-                const tagsFilter = args.tags;
-                const textFilter = args.text ? args.text.toLowerCase() : undefined;
-                for (const collId of targetIds) {
-                    const result = await store.get(collId);
-                    if (!result)
-                        continue;
-                    const { collection } = result;
-                    for (const [folderKey, folder] of Object.entries(collection.folders ?? {})) {
-                        if (folderFilter && folderKey !== folderFilter)
-                            continue;
-                        for (const ep of folder.endpoints ?? []) {
-                            if (methodFilter && ep.method.toUpperCase() !== methodFilter)
-                                continue;
-                            if (pathFilter && !ep.path.includes(pathFilter))
-                                continue;
-                            if (tagsFilter?.length && !tagsFilter.some((t) => ep.tags?.includes(t)))
-                                continue;
-                            if (textFilter) {
-                                const searchable = [ep.name, ep.description ?? "", ep.path].join(" ").toLowerCase();
-                                if (!searchable.includes(textFilter))
-                                    continue;
-                            }
-                            results.push({
-                                collection: collId,
-                                folder: folderKey,
-                                endpoint: {
-                                    name: ep.name,
-                                    method: ep.method,
-                                    path: ep.path,
-                                    ...(ep.description && { description: ep.description }),
-                                    ...(ep.tags?.length && { tags: ep.tags }),
-                                },
-                            });
-                        }
-                    }
-                }
-                return { count: results.length, results };
-            }
-            case "neuron_api_generate_tests": {
-                const id = args.collection;
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                const { collection } = result;
-                const folderKey = slugify(args.folder);
-                const folder = collection.folders?.[folderKey];
-                if (!folder)
-                    return { error: `Folder '${args.folder}' not found` };
-                const method = args.method.toUpperCase();
-                const endpoint = folder.endpoints?.find((ep) => ep.method.toUpperCase() === method && ep.path === args.path);
-                if (!endpoint)
-                    return { error: `Endpoint ${method} ${args.path} not found` };
-                const suggestions = [];
-                // Status code suggestions based on method
-                switch (method) {
-                    case "GET":
-                        suggestions.push({ check: "status", expect: 200, reason: "GET should return 200 OK" });
-                        break;
-                    case "POST":
-                        suggestions.push({ check: "status", expect: 201, reason: "POST creating a resource should return 201 Created" });
-                        break;
-                    case "PUT":
-                    case "PATCH":
-                        suggestions.push({ check: "status", expect: 200, reason: `${method} should return 200 OK` });
-                        break;
-                    case "DELETE":
-                        suggestions.push({ check: "status", expect: 200, reason: "DELETE should return 200 OK or 204 No Content" });
-                        break;
-                    default:
-                        suggestions.push({ check: "status", expect: 200, reason: "Expected success status" });
-                }
-                // Timing suggestion
-                suggestions.push({
-                    check: "timing.total",
-                    op: "lt",
-                    expect: 2000,
-                    reason: "Response should complete within 2 seconds",
-                });
-                // Content-type suggestion
-                suggestions.push({
-                    check: "header.content-type",
-                    op: "contains",
-                    expect: "json",
-                    reason: "API should return JSON content type",
-                });
-                // ID field suggestion for POST/GET with resource
-                if (method === "POST") {
-                    suggestions.push({
-                        check: "body.id",
-                        op: "exists",
-                        reason: "Created resource should return an ID",
-                    });
-                }
-                // Array suggestion for GET list endpoints (path doesn't end with a variable)
-                if (method === "GET" && !endpoint.path.includes("{{")) {
-                    suggestions.push({
-                        check: "body",
-                        op: "isArray",
-                        reason: "GET list endpoint should return an array",
-                    });
-                }
-                // 404 error scenario for endpoints with path parameters
-                if (endpoint.path.includes("{{")) {
-                    suggestions.push({
-                        check: "status",
-                        expect: 404,
-                        reason: "Error scenario: non-existent resource should return 404 (use with a fake ID)",
-                    });
-                }
-                return {
-                    endpoint: { method: endpoint.method, path: endpoint.path, name: endpoint.name },
-                    existing_tests: endpoint.tests?.length ?? 0,
-                    suggestions,
-                };
-            }
-            // ── Import / Export ─────────────────────────────────────
-            case "neuron_api_export_collection": {
-                const id = args.collection;
-                const format = args.format ?? "yaml";
-                const result = await store.get(id);
-                if (!result)
-                    return { error: `Collection '${id}' not found` };
-                let content;
-                let filename;
-                if (format === "postman") {
-                    const postman = toPostmanV21(result.collection, id);
-                    content = JSON.stringify(postman, null, 2);
-                    filename = `${id}.postman_collection.json`;
-                }
-                else {
-                    content = YAML.stringify(result.collection, { lineWidth: 120 });
-                    filename = `${id}.yaml`;
-                }
-                return { content, format, filename };
-            }
-            case "neuron_api_import_collection": {
-                const raw = args.content;
-                const formatHint = args.format ?? "auto";
-                const location = args.location ?? "global";
-                const imported = parseImportContent(raw, formatHint);
-                if (args.name)
-                    imported.name = args.name;
-                const id = slugify(imported.name);
-                if (!id)
-                    return { error: "Collection name produces an empty slug" };
-                const savePath = await store.save(id, imported, location);
-                const endpointCount = imported.folders
-                    ? Object.values(imported.folders).reduce((s, f) => s + (f.endpoints?.length ?? 0), 0)
-                    : 0;
-                return { id, name: imported.name, endpoint_count: endpointCount, path: savePath };
-            }
-            case "neuron_api_import_file": {
-                const filePath = args.path;
-                const location = args.location ?? "global";
-                let raw;
-                try {
-                    raw = await readFile(filePath, "utf-8");
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    return { error: `Cannot read file: ${msg}` };
-                }
-                // Detect format from extension
-                const ext = filePath.toLowerCase();
-                let formatHint = "auto";
-                if (ext.endsWith(".json") || ext.endsWith(".postman_collection.json")) {
-                    formatHint = "postman";
-                }
-                else if (ext.endsWith(".yaml") || ext.endsWith(".yml")) {
-                    formatHint = "yaml";
-                }
-                const imported = parseImportContent(raw, formatHint);
-                if (args.name)
-                    imported.name = args.name;
-                const id = slugify(imported.name);
-                if (!id)
-                    return { error: "Collection name produces an empty slug" };
-                const savePath = await store.save(id, imported, location);
-                const endpointCount = imported.folders
-                    ? Object.values(imported.folders).reduce((s, f) => s + (f.endpoints?.length ?? 0), 0)
-                    : 0;
-                return { id, name: imported.name, endpoint_count: endpointCount, path: savePath };
-            }
-            default:
-                return { error: `Unknown collection tool: ${name}` };
-        }
-    };
-}
-// ── Import helpers ────────────────────────────────────────────────
-function isPostmanJson(obj) {
-    if (typeof obj !== "object" || obj === null)
-        return false;
-    const root = obj;
-    const info = root.info;
-    if (!info)
-        return false;
-    const schema = info.schema;
-    return typeof schema === "string" && schema.includes("postman");
-}
-function parseImportContent(raw, formatHint) {
-    // Try JSON first if hint suggests Postman or auto
-    if (formatHint === "postman" || formatHint === "auto") {
-        try {
-            const parsed = JSON.parse(raw);
-            if (formatHint === "postman" || isPostmanJson(parsed)) {
-                return fromPostmanV21(parsed);
-            }
-            // Valid JSON but not Postman — fall through to YAML
-        }
-        catch {
-            if (formatHint === "postman") {
-                throw new Error("Content is not valid JSON for Postman format");
-            }
-            // Not JSON — try YAML
-        }
-    }
-    // Parse as YAML
-    const parsed = YAML.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || typeof parsed.name !== "string") {
-        throw new Error("Invalid collection: must be an object with a 'name' field");
-    }
-    return parsed;
-}
-//# sourceMappingURL=tools.js.map