@chanl-ai/cli 2.0.1

package/dist/commands/tools.js

@@ -0,0 +1,632 @@
+import { Command } from "commander";
+import { readFile } from "fs/promises";
+import { confirm } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import { createSdk } from "../utils/sdk-factory.js";
+import {
+  printSuccess,
+  printError,
+  printInfo,
+  printLabel,
+  printBlank,
+  printSimpleTable,
+  isJsonOutput,
+  printJson,
+  formatDate
+} from "../utils/output.js";
+const TOOL_TEMPLATES = {
+  http: {
+    name: "my-api-tool",
+    description: "Calls an external API endpoint",
+    type: "http",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" }
+      },
+      required: ["query"]
+    },
+    configuration: {
+      http: {
+        method: "POST",
+        url: "https://api.example.com/search",
+        headers: { "Content-Type": "application/json" },
+        bodyTemplate: '{"q": "{{query}}"}'
+      }
+    },
+    isEnabled: true,
+    tags: ["api", "search"]
+  },
+  javascript: {
+    name: "my-js-tool",
+    description: "Executes JavaScript code",
+    type: "javascript",
+    inputSchema: {
+      type: "object",
+      properties: {
+        a: { type: "number", description: "First number" },
+        b: { type: "number", description: "Second number" }
+      },
+      required: ["a", "b"]
+    },
+    configuration: {
+      javascript: {
+        code: "return { result: args.a + args.b };"
+      }
+    },
+    isEnabled: true
+  }
+};
+function createToolsCommand() {
+  const tools = new Command("tools").description("Manage MCP tools");
+  tools.command("list").description("List all tools in the workspace").option("-t, --type <type>", "Filter by type: http, javascript, code").option("-e, --enabled", "Show only enabled tools").option("-d, --disabled", "Show only disabled tools").option("--tag <tag>", "Filter by tag (e.g., --tag api)").option("--no-system", "Exclude system tools (kb_search, chanl_reason, etc.)").option("-l, --limit <number>", "Items per page (default: 20)", "20").option("-p, --page <number>", "Page number (default: 1)", "1").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools list                    # List all tools
+  $ chanl tools list --enabled          # Only enabled tools
+  $ chanl tools list --type http        # Only HTTP tools
+  $ chanl tools list --tag api          # Filter by tag
+  $ chanl tools list --no-system        # Exclude system tools
+  $ chanl tools list --json             # Output as JSON`
+  ).action(handleToolsList);
+  tools.command("get <id>").description("Get detailed info about a tool").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools get 507f1f77bcf86cd799439011
+  $ chanl tools get 507f1f77bcf86cd799439011 --json`
+  ).action(handleToolsGet);
+  tools.command("create").description("Create a new tool from JSON file").option("-f, --file <path>", "Path to JSON file with tool definition").option("--template [type]", "Output a sample JSON template (http or javascript)").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools create --template http > my-tool.json  # Generate template
+  $ chanl tools create -f my-tool.json                 # Create from file
+
+Required JSON fields:
+  name          Tool name (used in MCP)
+  description   What the tool does
+  type          "http" | "javascript" | "code"
+  inputSchema   JSON Schema for input parameters
+  configuration Tool-specific config (http.url, http.method, etc.)
+
+Optional fields:
+  isEnabled     Enable immediately (default: true)
+  tags          Array of category tags
+
+Run 'chanl tools create --template' to see full structure.`
+  ).action(handleToolsCreate);
+  tools.command("update <id>").description("Update a tool from JSON file").requiredOption("-f, --file <path>", "Path to JSON file with updates").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools update 507f1f77bcf86cd799439011 -f updates.json
+
+The JSON file only needs fields you want to change:
+  {"description": "Updated description", "isEnabled": false}`
+  ).action(handleToolsUpdate);
+  tools.command("delete <id>").description("Delete a tool permanently").option("-y, --yes", "Skip confirmation prompt").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools delete 507f1f77bcf86cd799439011       # With confirmation
+  $ chanl tools delete 507f1f77bcf86cd799439011 -y    # Skip confirmation`
+  ).action(handleToolsDelete);
+  tools.command("execute <id>").description("Execute a tool and get results").requiredOption("-i, --input <json>", "Input arguments as JSON string").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools execute 507f1f77bcf86cd799439011 -i '{"query": "hello"}'
+  $ chanl tools execute my-tool-id -i '{"location": "London"}' --json`
+  ).action(handleToolsExecute);
+  tools.command("test <id>").description("Test a tool execution (dry run)").requiredOption("-i, --input <json>", "Input arguments as JSON string").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools test 507f1f77bcf86cd799439011 -i '{"message": "test"}'`
+  ).action(handleToolsTest);
+  tools.command("executions <id>").description("Get execution history for a tool").option("-l, --limit <number>", "Items per page (default: 10)", "10").option("-p, --page <number>", "Page number (default: 1)", "1").option("--status <status>", "Filter: pending, running, completed, failed").addHelpText(
+    "after",
+    `
+Examples:
+  $ chanl tools executions 507f1f77bcf86cd799439011
+  $ chanl tools executions my-tool-id --status failed --limit 5`
+  ).action(handleToolsExecutions);
+  tools.command("enable <id>").description("Enable a tool (makes it available in MCP)").action(handleToolsEnable);
+  tools.command("disable <id>").description("Disable a tool (hides from MCP)").action(handleToolsDisable);
+  tools.command("categories").description("Show tool categories (tags) with counts").addHelpText(
+    "after",
+    `
+Shows all tags used across tools with:
+  - Total tools in each category
+  - Number of enabled tools`
+  ).action(handleToolsCategories);
+  return tools;
+}
+async function handleToolsList(options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching tools...").start();
+  try {
+    let isEnabled;
+    if (options.enabled) isEnabled = true;
+    else if (options.disabled) isEnabled = false;
+    const response = await sdk.tools.list({
+      type: options.type,
+      isEnabled,
+      tag: options.tag,
+      includeSystem: options.system,
+      // --no-system sets this to false
+      limit: parseInt(options.limit, 10),
+      page: parseInt(options.page, 10)
+    });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch tools", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { tools, total, pagination } = response.data;
+    if (isJsonOutput()) {
+      printJson({ tools, total, pagination });
+      return;
+    }
+    if (tools.length === 0) {
+      printInfo("No tools found");
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["Name", "Type", "Enabled", "Tags", "Last Called"],
+      tools.map((tool) => [
+        tool.name,
+        tool.type,
+        tool.isEnabled ? chalk.green("\u2713") : chalk.red("\u2717"),
+        tool.tags.length > 0 ? tool.tags.join(", ") : "-",
+        tool.stats.lastCalledAt ? formatDate(tool.stats.lastCalledAt) : "Never"
+      ])
+    );
+    printBlank();
+    printInfo(`Total: ${total} tools (Page ${pagination.page} of ${pagination.totalPages})`);
+  } catch (error) {
+    spinner.fail("Failed to fetch tools");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsGet(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching tool...").start();
+  try {
+    const response = await sdk.tools.get(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { tool } = response.data;
+    if (isJsonOutput()) {
+      printJson(tool);
+      return;
+    }
+    printBlank();
+    printToolDetails(tool);
+  } catch (error) {
+    spinner.fail("Failed to fetch tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsCreate(options) {
+  if (options.template !== void 0) {
+    const templateType = typeof options.template === "string" ? options.template : "http";
+    const template = TOOL_TEMPLATES[templateType];
+    if (!template) {
+      printError("Unknown template type", `Available: http, javascript`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(template, null, 2));
+    return;
+  }
+  if (!options.file) {
+    printError("Missing required option", "Use '-f, --file <path>' or '--template' for sample JSON");
+    printInfo("Run 'chanl tools create --help' for usage");
+    process.exitCode = 1;
+    return;
+  }
+  const sdk = createSdk();
+  if (!sdk) return;
+  let input;
+  try {
+    const content = await readFile(options.file, "utf-8");
+    input = JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Failed to read file", message);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Creating tool...").start();
+  try {
+    const response = await sdk.tools.create(input);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to create tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { tool } = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, tool });
+      return;
+    }
+    printSuccess(`Created tool: ${tool.name} (${tool.id})`);
+  } catch (error) {
+    spinner.fail("Failed to create tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsUpdate(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  let input;
+  try {
+    const content = await readFile(options.file, "utf-8");
+    input = JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Failed to read file", message);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Updating tool...").start();
+  try {
+    const response = await sdk.tools.update(id, input);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to update tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { tool } = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, tool });
+      return;
+    }
+    printSuccess(`Updated tool: ${tool.name} (${tool.id})`);
+  } catch (error) {
+    spinner.fail("Failed to update tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsDelete(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  if (!options.yes) {
+    try {
+      const confirmed = await confirm({
+        message: `Are you sure you want to delete tool '${id}'?`,
+        default: false
+      });
+      if (!confirmed) {
+        printInfo("Deletion cancelled");
+        return;
+      }
+    } catch {
+      printBlank();
+      printInfo("Deletion cancelled");
+      return;
+    }
+  }
+  const spinner = ora("Deleting tool...").start();
+  try {
+    const response = await sdk.tools.delete(id);
+    spinner.stop();
+    if (!response.success) {
+      printError("Failed to delete tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    if (isJsonOutput()) {
+      printJson({ success: true, deleted: true, id });
+      return;
+    }
+    printSuccess(`Deleted tool: ${id}`);
+  } catch (error) {
+    spinner.fail("Failed to delete tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsExecute(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  let args;
+  try {
+    args = JSON.parse(options.input);
+  } catch {
+    printError("Invalid JSON input", `Could not parse: ${options.input}`);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Executing tool...").start();
+  try {
+    const response = await sdk.tools.execute(id, args);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Execution failed", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const execution = response.data;
+    if (isJsonOutput()) {
+      printJson(execution);
+      return;
+    }
+    printExecutionResult(execution);
+  } catch (error) {
+    spinner.fail("Execution failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsTest(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  let args;
+  try {
+    args = JSON.parse(options.input);
+  } catch {
+    printError("Invalid JSON input", `Could not parse: ${options.input}`);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = ora("Testing tool...").start();
+  try {
+    const response = await sdk.tools.test(id, args);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Test failed", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const execution = response.data;
+    if (isJsonOutput()) {
+      printJson(execution);
+      return;
+    }
+    printInfo("Test execution:");
+    printExecutionResult(execution);
+  } catch (error) {
+    spinner.fail("Test failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsExecutions(id, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching executions...").start();
+  try {
+    const response = await sdk.tools.getExecutions(id, {
+      limit: parseInt(options.limit, 10),
+      page: parseInt(options.page, 10),
+      status: options.status
+    });
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch executions", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { data: executions, total, pagination } = response.data;
+    if (isJsonOutput()) {
+      printJson({ executions, total, pagination });
+      return;
+    }
+    if (executions.length === 0) {
+      printInfo("No executions found");
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["Execution ID", "Status", "Duration", "Source", "Created"],
+      executions.map((exec) => [
+        exec.id.substring(0, 12) + "...",
+        formatStatus(exec.status),
+        exec.executionTimeMs ? `${exec.executionTimeMs}ms` : "-",
+        exec.source,
+        formatDate(exec.createdAt)
+      ])
+    );
+    printBlank();
+    printInfo(`Total: ${total} executions (Page ${pagination.page} of ${pagination.totalPages})`);
+  } catch (error) {
+    spinner.fail("Failed to fetch executions");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsEnable(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Enabling tool...").start();
+  try {
+    const response = await sdk.tools.enable(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to enable tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { tool } = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, tool });
+      return;
+    }
+    printSuccess(`Enabled tool: ${tool.name} (${tool.id})`);
+  } catch (error) {
+    spinner.fail("Failed to enable tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsDisable(id) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Disabling tool...").start();
+  try {
+    const response = await sdk.tools.disable(id);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to disable tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { tool } = response.data;
+    if (isJsonOutput()) {
+      printJson({ success: true, tool });
+      return;
+    }
+    printSuccess(`Disabled tool: ${tool.name} (${tool.id})`);
+  } catch (error) {
+    spinner.fail("Failed to disable tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleToolsCategories() {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching categories...").start();
+  try {
+    const response = await sdk.tools.getCategories();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch categories", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { categories, uncategorized } = response.data;
+    if (isJsonOutput()) {
+      printJson({ categories, uncategorized });
+      return;
+    }
+    if (categories.length === 0 && uncategorized.count === 0) {
+      printInfo("No categories found");
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["Category", "Total", "Enabled"],
+      [
+        ...categories.map((cat) => [
+          cat.tag,
+          cat.count.toString(),
+          `${cat.enabled} (${Math.round(cat.enabled / cat.count * 100)}%)`
+        ]),
+        [
+          chalk.gray("(uncategorized)"),
+          uncategorized.count.toString(),
+          uncategorized.count > 0 ? `${uncategorized.enabled} (${Math.round(uncategorized.enabled / uncategorized.count * 100)}%)` : "0 (0%)"
+        ]
+      ]
+    );
+    const totalCount = categories.reduce((sum, c) => sum + c.count, 0) + uncategorized.count;
+    const totalEnabled = categories.reduce((sum, c) => sum + c.enabled, 0) + uncategorized.enabled;
+    printBlank();
+    printInfo(`Total: ${totalCount} tools, ${totalEnabled} enabled`);
+  } catch (error) {
+    spinner.fail("Failed to fetch categories");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+function printToolDetails(tool) {
+  printLabel("Name", tool.name);
+  printLabel("ID", tool.id);
+  printLabel("Type", tool.type);
+  printLabel("Enabled", tool.isEnabled ? chalk.green("Yes") : chalk.red("No"));
+  printLabel("Description", tool.description);
+  if (tool.tags.length > 0) {
+    printLabel("Tags", tool.tags.join(", "));
+  }
+  printBlank();
+  printInfo("Input Schema:");
+  console.log(chalk.gray(JSON.stringify(tool.inputSchema, null, 2)));
+  printBlank();
+  printInfo("Configuration:");
+  console.log(chalk.gray(JSON.stringify(tool.configuration, null, 2)));
+  printBlank();
+  printInfo("Statistics:");
+  printLabel("  Total Calls", tool.stats.totalCalls.toString());
+  printLabel("  Successful", tool.stats.successfulCalls.toString());
+  printLabel("  Failed", tool.stats.failedCalls.toString());
+  printLabel("  Avg Latency", `${tool.stats.averageLatencyMs}ms`);
+  if (tool.stats.lastCalledAt) {
+    printLabel("  Last Called", formatDate(tool.stats.lastCalledAt));
+  }
+  printBlank();
+  printLabel("Created", formatDate(tool.createdAt));
+  printLabel("Updated", formatDate(tool.updatedAt));
+  printBlank();
+}
+function printExecutionResult(result) {
+  printBlank();
+  const statusText = result.success ? chalk.green("\u2713 Success") : chalk.red("\u2717 Failed");
+  printLabel("Status", statusText);
+  if (result.latencyMs) {
+    printLabel("Duration", `${result.latencyMs}ms`);
+  }
+  if (result.executionId) {
+    printLabel("Execution ID", result.executionId);
+  }
+  if (!result.success && result.error) {
+    printBlank();
+    printError("Error", result.error);
+  }
+  if (result.data) {
+    printBlank();
+    printInfo("Output:");
+    console.log(chalk.gray(JSON.stringify(result.data, null, 2)));
+  }
+  printBlank();
+}
+function formatStatus(status) {
+  switch (status) {
+    case "completed":
+      return chalk.green("\u2713 completed");
+    case "failed":
+      return chalk.red("\u2717 failed");
+    case "running":
+      return chalk.blue("\u22EF running");
+    case "pending":
+      return chalk.gray("\u25CB pending");
+    case "corrected":
+      return chalk.yellow("\u26A1 corrected");
+    default:
+      return status;
+  }
+}
+export {
+  createToolsCommand
+};
+//# sourceMappingURL=tools.js.map