@evantahler/mcpcli 0.3.0 → 0.3.3

package/README.md

@@ -32,7 +32,7 @@ mcpcli -d
 mcpcli info github
 
 # Inspect a specific tool
-mcpcli info github/search_repositories
+mcpcli info github search_repositories
 
 # Call a tool
 mcpcli call github search_repositories '{"query": "mcp server"}'
@@ -53,7 +53,7 @@ mcpcli search -q "manage pull requests"
 | ------------------------------------ | -------------------------------------------- |
 | `mcpcli`                             | List all configured servers and tools        |
 | `mcpcli info <server>`               | Show tools for a server                      |
-| `mcpcli info <server>/<tool>`        | Show tool schema                             |
+| `mcpcli info <server> <tool>`        | Show tool schema                             |
 | `mcpcli search <query>`              | Search tools (keyword + semantic)            |
 | `mcpcli search -k <pattern>`         | Keyword/glob search only                     |
 | `mcpcli search -q <query>`           | Semantic search only                         |
@@ -415,7 +415,7 @@ cp skills/mcpcli.md ~/.claude/skills/mcpcli.md
 Then in any Claude Code session, the agent can use `/mcpcli` or the skill triggers automatically when the agent needs to interact with external services. The skill instructs the agent to:
 
 1. **Search first** — `mcpcli search "<intent>"` to find relevant tools
-2. **Inspect** — `mcpcli info <server>/<tool>` to get the schema before calling
+2. **Inspect** — `mcpcli info <server> <tool>` to get the schema before calling
 3. **Call** — `mcpcli call <server> <tool> '<json>'` to execute
 
 This keeps tool schemas out of the system prompt entirely. The agent discovers what it needs on-demand, saving tokens and context window space.
@@ -430,7 +430,7 @@ You have access to MCP tools via the `mcpcli` CLI.
 To discover tools:
   mcpcli search "<what you want to do>"    # combined keyword + semantic
   mcpcli search -k "<pattern>"             # keyword/glob only
-  mcpcli info <server>/<tool>              # tool schema
+  mcpcli info <server> <tool>              # tool schema
 
 To call tools:
   mcpcli call <server> <tool> '<json args>'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evantahler/mcpcli",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "A command-line interface for MCP servers. curl for MCP.",
   "type": "module",
   "bin": {

package/skills/mcpcli.md

@@ -17,10 +17,10 @@ mcpcli search "<what you want to do>"
 ## 2. Inspect the tool schema
 
 ```bash
-mcpcli call <server> <tool>
+mcpcli info <server> <tool>
 ```
 
-This shows parameters, types, required fields, and an example payload.
+This shows parameters, types, required fields, and the full JSON Schema.
 
 ## 3. Call the tool
 
@@ -34,7 +34,6 @@ mcpcli call <server> <tool> '<json args>'
 - Always inspect the schema before calling — validate you have the right arguments
 - Use `mcpcli search -k` for exact name matching
 - Pipe results through `jq` when you need to extract specific fields
-- Tool call results are always JSON with nested JSON strings auto-parsed
 - Use `-v` for verbose HTTP debugging if a call fails unexpectedly
 
 ## Examples
@@ -44,14 +43,14 @@ mcpcli call <server> <tool> '<json args>'
 mcpcli search "send a message"
 
 # See what parameters Slack_SendMessage needs
-mcpcli call arcade Slack_SendMessage
+mcpcli info arcade Slack_SendMessage
 
 # Send a message
 mcpcli call arcade Slack_SendMessage '{"channel":"#general","message":"hello"}'
 
 # Chain commands — search repos and read the first result
 mcpcli call github search_repositories '{"query":"mcp"}' \
-  | jq -r '.content[0].text.items[0].full_name' \
+  | jq -r '.content[0].text | fromjson | .items[0].full_name' \
   | xargs -I {} mcpcli call github get_file_contents '{"owner":"{}","path":"README.md"}'
 
 # Read args from stdin
@@ -64,22 +63,30 @@ Some HTTP servers require OAuth. If you see an "Not authenticated" error:
 
 ```bash
 mcpcli auth <server>        # authenticate via browser
-mcpcli auth <server> -s        # check token status
+mcpcli auth <server> -s     # check token status and TTL
+mcpcli auth <server> -r     # force token refresh
 mcpcli deauth <server>      # remove stored auth
 ```
 
 ## Available commands
 
-| Command                                | Purpose                            |
-| -------------------------------------- | ---------------------------------- |
-| `mcpcli`                               | List all servers and tools         |
-| `mcpcli -d`                            | List with descriptions             |
-| `mcpcli call <server>`                 | List tools for a server            |
-| `mcpcli call <server> <tool>`          | Show tool help and example payload |
-| `mcpcli call <server> <tool> '<json>'` | Execute a tool                     |
-| `mcpcli info <server>/<tool>`          | Show tool schema                   |
-| `mcpcli search "<query>"`              | Search tools                       |
-| `mcpcli search -k "<pattern>"`         | Keyword/glob search only           |
-| `mcpcli search -q "<query>"`           | Semantic search only               |
-| `mcpcli index`                         | Build/rebuild search index         |
-| `mcpcli auth <server>`                 | Authenticate with OAuth            |
+| Command                                | Purpose                           |
+| -------------------------------------- | --------------------------------- |
+| `mcpcli`                               | List all servers and tools        |
+| `mcpcli -d`                            | List with descriptions            |
+| `mcpcli info <server>`                 | Show tools for a server           |
+| `mcpcli info <server> <tool>`          | Show tool schema                  |
+| `mcpcli call <server>`                 | List tools for a server           |
+| `mcpcli call <server> <tool> '<json>'` | Execute a tool                    |
+| `mcpcli search "<query>"`              | Search tools (keyword + semantic) |
+| `mcpcli search -k "<pattern>"`         | Keyword/glob search only          |
+| `mcpcli search -q "<query>"`           | Semantic search only              |
+| `mcpcli index`                         | Build/rebuild search index        |
+| `mcpcli index -i`                      | Show index status                 |
+| `mcpcli auth <server>`                 | Authenticate with OAuth           |
+| `mcpcli auth <server> -s`              | Check token status and TTL        |
+| `mcpcli auth <server> -r`              | Force token refresh               |
+| `mcpcli deauth <server>`               | Remove stored authentication      |
+| `mcpcli add <name> --command <cmd>`    | Add a stdio MCP server            |
+| `mcpcli add <name> --url <url>`        | Add an HTTP MCP server            |
+| `mcpcli remove <name>`                 | Remove an MCP server              |

package/src/commands/call.ts

@@ -4,7 +4,6 @@ import {
   formatCallResult,
   formatError,
   formatServerTools,
-  formatToolHelp,
   formatValidationErrors,
 } from "../output/formatter.ts";
 import { startSpinner } from "../output/spinner.ts";
@@ -30,18 +29,6 @@ export function registerCallCommand(program: Command) {
         return;
       }
       try {
-        // No args + interactive terminal → show tool help with example payload
-        const hasArgs = !!argsStr;
-        const hasStdin = !process.stdin.isTTY;
-        if (!hasArgs && !hasStdin) {
-          const toolSchema = await manager.getToolSchema(server, tool);
-          if (toolSchema) {
-            console.log(formatToolHelp(server, toolSchema, formatOptions));
-            await manager.close();
-            return;
-          }
-        }
-
         // Parse args from argument, stdin, or empty
         let args: Record<string, unknown> = {};
 

package/src/commands/info.ts

@@ -5,31 +5,27 @@ import { startSpinner } from "../output/spinner.ts";
 
 export function registerInfoCommand(program: Command) {
   program
-    .command("info <target>")
+    .command("info <server> [tool]")
     .description("show tools for a server, or schema for a specific tool")
-    .action(async (target: string) => {
+    .action(async (server: string, tool: string | undefined) => {
       const { manager, formatOptions } = await getContext(program);
+      const target = tool ? `${server}/${tool}` : server;
       const spinner = startSpinner(`Connecting to ${target}...`, formatOptions);
       try {
-        // Parse "server/tool" or "server tool" format
-        const slashIndex = target.indexOf("/");
-        if (slashIndex !== -1) {
-          const serverName = target.slice(0, slashIndex);
-          const toolName = target.slice(slashIndex + 1);
-          const tool = await manager.getToolSchema(serverName, toolName);
+        if (tool) {
+          const toolSchema = await manager.getToolSchema(server, tool);
           spinner.stop();
-          if (!tool) {
+          if (!toolSchema) {
             console.error(
-              formatError(`Tool "${toolName}" not found on server "${serverName}"`, formatOptions),
+              formatError(`Tool "${tool}" not found on server "${server}"`, formatOptions),
             );
             process.exit(1);
           }
-          console.log(formatToolSchema(serverName, tool, formatOptions));
+          console.log(formatToolSchema(server, toolSchema, formatOptions));
         } else {
-          // Just a server name — list its tools
-          const tools = await manager.listTools(target);
+          const tools = await manager.listTools(server);
           spinner.stop();
-          console.log(formatServerTools(target, tools, formatOptions));
+          console.log(formatServerTools(server, tools, formatOptions));
         }
       } catch (err) {
         spinner.error(`Failed to connect to ${target}`);