@rainfall-devkit/sdk 0.2.2 → 0.2.3

package/dist/cli/index.mjs

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
 import {
-  createEdgeNodeSecurity
-} from "../chunk-NCQVOLS4.mjs";
+  createEdgeNodeSecurity,
+  globalHandlerRegistry
+} from "../chunk-6FXRLPLR.mjs";
 import {
   Rainfall
-} from "../chunk-VDPKDC3R.mjs";
+} from "../chunk-CQ5TV7CQ.mjs";
+import "../chunk-LJQEO3CY.mjs";
+import {
+  formatResult
+} from "../chunk-XHPFY5MH.mjs";
 import {
   getConfigDir,
   loadConfig,
@@ -66,7 +71,12 @@ Options for 'run':
   --params, -p <json>           Tool parameters as JSON
   --file, -f <path>             Read parameters from file
   --raw                         Output raw JSON
+  --table                       Output as table (if applicable)
+  --terminal                    Output for terminal consumption (minimal formatting)
   --<key> <value>               Pass individual parameters (e.g., --query "AI news")
+                                Arrays: --tickers AAPL,GOOGL (comma-separated)
+                                Numbers: --count 42
+                                Booleans: --enabled true
 
 Options for 'daemon start':
   --port <port>                 WebSocket port (default: 8765)
@@ -82,6 +92,7 @@ Examples:
   rainfall tools describe github-create-issue
   rainfall run exa-web-search -p '{"query": "AI news"}'
   rainfall run exa-web-search --query "AI news"
+  rainfall run finviz-quotes --tickers AAPL,GOOGL,MSFT
   rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run article-summarize -f ./article.json
   rainfall daemon start
@@ -99,6 +110,24 @@ function getRainfall() {
     baseUrl: config.baseUrl
   });
 }
+async function fetchAllNodeIds(rainfall) {
+  try {
+    const client = rainfall.getClient();
+    const subscriberId = await client.ensureSubscriberId();
+    const result = await client.request(
+      `/olympic/subscribers/${subscriberId}/nodes/_utils/node-list`
+    );
+    if (result.keys && Array.isArray(result.keys)) {
+      return result.keys;
+    }
+    if (result.nodes && Array.isArray(result.nodes)) {
+      return result.nodes.map((n) => n.id);
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
 async function authLogin(args) {
   const apiKey = args[0] || process.env.RAINFALL_API_KEY;
   if (!apiKey) {
@@ -185,6 +214,100 @@ function formatSchema(obj, indent = 0) {
   }
   return lines.join("\n");
 }
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function jaroWinklerSimilarity(a, b) {
+  if (a === b) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const matchDistance = Math.floor(Math.max(a.length, b.length) / 2) - 1;
+  const aMatches = new Array(a.length).fill(false);
+  const bMatches = new Array(b.length).fill(false);
+  let matches = 0;
+  let transpositions = 0;
+  for (let i = 0; i < a.length; i++) {
+    const start = Math.max(0, i - matchDistance);
+    const end = Math.min(i + matchDistance + 1, b.length);
+    for (let j = start; j < end; j++) {
+      if (bMatches[j] || a.charAt(i) !== b.charAt(j)) continue;
+      aMatches[i] = true;
+      bMatches[j] = true;
+      matches++;
+      break;
+    }
+  }
+  if (matches === 0) return 0;
+  let k = 0;
+  for (let i = 0; i < a.length; i++) {
+    if (!aMatches[i]) continue;
+    while (!bMatches[k]) k++;
+    if (a.charAt(i) !== b.charAt(k)) transpositions++;
+    k++;
+  }
+  const jaro = (matches / a.length + matches / b.length + (matches - transpositions / 2) / matches) / 3;
+  let prefixLength = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    if (a.charAt(i) === b.charAt(i)) {
+      prefixLength++;
+    } else {
+      break;
+    }
+  }
+  const scalingFactor = 0.1;
+  return jaro + prefixLength * scalingFactor * (1 - jaro);
+}
+function calculateSimilarity(toolId, candidateId, description = "") {
+  const lowerToolId = toolId.toLowerCase();
+  const lowerCandidate = candidateId.toLowerCase();
+  const prefix = lowerToolId.split("-")[0];
+  const hasPrefix = lowerToolId.includes("-");
+  const jwScore = jaroWinklerSimilarity(lowerToolId, lowerCandidate);
+  const maxLen = Math.max(lowerToolId.length, lowerCandidate.length);
+  const lvScore = maxLen === 0 ? 1 : 1 - levenshteinDistance(lowerToolId, lowerCandidate) / maxLen;
+  let substringBoost = 0;
+  if (lowerCandidate.includes(lowerToolId) || lowerToolId.includes(lowerCandidate)) {
+    substringBoost = 0.4;
+  }
+  let prefixBoost = 0;
+  if (hasPrefix && lowerCandidate === prefix) {
+    prefixBoost = 0.5;
+  }
+  if (hasPrefix && lowerCandidate.startsWith(prefix + "-")) {
+    prefixBoost = 0.35;
+  }
+  const descMatch = description.toLowerCase().includes(lowerToolId) ? 0.1 : 0;
+  return jwScore * 0.4 + lvScore * 0.25 + substringBoost + prefixBoost + descMatch;
+}
+function findSimilarToolIds(toolId, toolIds) {
+  const scored = toolIds.map((id) => ({
+    id,
+    score: calculateSimilarity(toolId, id)
+  }));
+  return scored.filter((item) => item.score > 0.35).sort((a, b) => b.score - a.score).slice(0, 5).map((item) => item.id);
+}
 async function describeTool(args) {
   const toolId = args[0];
   if (!toolId) {
@@ -220,6 +343,17 @@ async function describeTool(args) {
     console.log();
   } catch (error) {
     console.error(`Error: Tool '${toolId}' not found`);
+    try {
+      const allNodeIds = await fetchAllNodeIds(rainfall);
+      const suggestions = findSimilarToolIds(toolId, allNodeIds);
+      if (suggestions.length > 0) {
+        console.error("\nDid you mean:");
+        for (const suggestion of suggestions) {
+          console.error(`  \u2022 ${suggestion}`);
+        }
+      }
+    } catch {
+    }
     process.exit(1);
   }
 }
@@ -263,12 +397,18 @@ Options:
   -p, --params <json>    Tool parameters as JSON string
   -f, --file <path>      Read parameters from JSON file
   --raw                  Output raw JSON (no formatting)
+  --table                Output as table (if applicable)
+  --terminal             Output for terminal consumption (minimal formatting)
   --<key> <value>        Pass individual parameters (e.g., --query "AI news")
+                         Arrays: --tickers AAPL,GOOGL (comma-separated)
+                         Numbers: --count 42
+                         Booleans: --enabled true
 
 Examples:
   rainfall run figma-users-getMe
   rainfall run exa-web-search -p '{"query": "AI news"}'
   rainfall run exa-web-search --query "AI news"
+  rainfall run finviz-quotes --tickers AAPL,GOOGL,MSFT
   rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run github-create-issue -f ./issue.json
   echo '{"query": "hello"}' | rainfall run exa-web-search
@@ -277,6 +417,7 @@ Examples:
   }
   let params = {};
   const rawArgs = [];
+  let displayMode = "pretty";
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--params" || arg === "-p") {
@@ -304,16 +445,17 @@ Examples:
         process.exit(1);
       }
     } else if (arg === "--raw") {
+      displayMode = "raw";
+    } else if (arg === "--table") {
+      displayMode = "table";
+    } else if (arg === "--terminal") {
+      displayMode = "terminal";
     } else if (arg.startsWith("--")) {
       const key = arg.slice(2);
       const value = args[++i];
       if (value === void 0) {
-        console.error(`Error: ${arg} requires a value`);
-        process.exit(1);
-      }
-      try {
-        params[key] = JSON.parse(value);
-      } catch {
+        params[key] = true;
+      } else {
         params[key] = value;
       }
     } else {
@@ -355,30 +497,108 @@ Examples:
     }
   }
   const rainfall = getRainfall();
-  if (rawArgs.length === 1 && Object.keys(params).length === 0) {
-    try {
-      const schema = await rainfall.getToolSchema(toolId);
-      if (schema.parameters && typeof schema.parameters === "object") {
-        const paramEntries = Object.entries(schema.parameters);
-        const requiredParams = paramEntries.filter(([, p]) => !p.optional);
-        if (requiredParams.length === 1) {
-          const [paramName] = requiredParams[0];
-          params = { [paramName]: rawArgs[0] };
-        }
+  let toolSchema;
+  try {
+    const fullSchema = await rainfall.getToolSchema(toolId);
+    toolSchema = {
+      parameters: fullSchema.parameters
+    };
+  } catch {
+  }
+  const cliFlags = /* @__PURE__ */ new Set(["--params", "-p", "--file", "-f", "--raw", "--table", "--terminal"]);
+  const toolArgs = args.slice(1).filter((arg, i, arr) => {
+    if (cliFlags.has(arg)) {
+      return false;
+    }
+    if (i > 0 && cliFlags.has(arr[i - 1])) {
+      return false;
+    }
+    return true;
+  });
+  if (toolSchema?.parameters) {
+    const { parseCliArgs } = await import("../param-parser-PAKCNDBX.mjs");
+    const parsedParams = parseCliArgs(
+      toolArgs,
+      {
+        name: toolId,
+        description: "",
+        category: "",
+        parameters: toolSchema.parameters
       }
-    } catch {
+    );
+    params = { ...parsedParams, ...params };
+  }
+  if (rawArgs.length === 1 && Object.keys(params).length === 0 && toolSchema?.parameters) {
+    const paramEntries = Object.entries(toolSchema.parameters);
+    const requiredParams = paramEntries.filter(([, p]) => !p.optional);
+    if (requiredParams.length === 1) {
+      const [paramName, paramSchema] = requiredParams[0];
+      const { parseValue } = await import("../param-parser-PAKCNDBX.mjs");
+      params = { [paramName]: parseValue(rawArgs[0], paramSchema) };
     }
   }
+  const handler = globalHandlerRegistry.findHandler(toolId);
+  const toolContext = {
+    rainfall,
+    toolId,
+    params,
+    args: rawArgs,
+    flags: { raw: displayMode === "raw" }
+  };
   try {
-    const result = await rainfall.executeTool(toolId, params);
-    if (args.includes("--raw")) {
-      console.log(JSON.stringify(result));
+    let executionParams = params;
+    let preflightContext;
+    let skipExecution;
+    if (handler?.preflight) {
+      const preflightResult = await handler.preflight(toolContext);
+      if (preflightResult) {
+        if (preflightResult.skipExecution !== void 0) {
+          skipExecution = preflightResult.skipExecution;
+        }
+        if (preflightResult.params) {
+          executionParams = preflightResult.params;
+        }
+        preflightContext = preflightResult.context;
+      }
+    }
+    let result;
+    if (skipExecution !== void 0) {
+      result = skipExecution;
     } else {
-      console.log(JSON.stringify(result, null, 2));
+      result = await rainfall.executeTool(toolId, executionParams);
+    }
+    const postflightContext = {
+      ...toolContext,
+      result,
+      preflightContext
+    };
+    if (handler?.postflight) {
+      await handler.postflight(postflightContext);
+    }
+    let displayed = false;
+    if (handler?.display) {
+      displayed = await handler.display({ ...postflightContext, flags: { ...toolContext.flags, mode: displayMode } });
+    }
+    if (!displayed) {
+      const output = await formatResult(result, { mode: displayMode });
+      console.log(output);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`Error: ${message}`);
+    if (message.toLowerCase().includes("not found") || message.toLowerCase().includes("not found")) {
+      try {
+        const allNodeIds = await fetchAllNodeIds(rainfall);
+        const suggestions = findSimilarToolIds(toolId, allNodeIds);
+        if (suggestions.length > 0) {
+          console.error("\nDid you mean:");
+          for (const suggestion of suggestions) {
+            console.error(`  \u2022 ${suggestion}`);
+          }
+        }
+      } catch {
+      }
+    }
     process.exit(1);
   }
 }

package/dist/daemon/index.d.mts

@@ -1,6 +1,6 @@
-import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-4OvXPr8E.mjs';
-export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-4OvXPr8E.mjs';
-import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-MNAnpZj-.mjs';
+import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-Cl5Qzt4I.mjs';
+export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-Cl5Qzt4I.mjs';
+import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-Ckdj6D8T.mjs';
 import 'ws';
 import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';

package/dist/daemon/index.d.ts

@@ -1,6 +1,6 @@
-import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-4OvXPr8E.js';
-export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-4OvXPr8E.js';
-import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-B5Vy9Ao5.js';
+import { R as RainfallConfig, g as MCPClientConfig, h as MCPProxyHub } from '../sdk-Cl5Qzt4I.js';
+export { i as MCPClientInfo, j as MCPToolInfo, k as MCPTransportType } from '../sdk-Cl5Qzt4I.js';
+import { N as NetworkedExecutorOptions, C as ContextOptions, R as RainfallNetworkedExecutor, a as RainfallDaemonContext, b as RainfallListenerRegistry } from '../listeners-BBNBsJCk.js';
 import 'ws';
 import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';