quiver-cli 1.2.0 → 1.3.0

package/dist/cli.js

@@ -2499,6 +2499,31 @@ var init_update = __esm({
   }
 });
 
+// src/mcp/tokens.ts
+var estimateTokens, formatTokens, sumTokens;
+var init_tokens = __esm({
+  "src/mcp/tokens.ts"() {
+    "use strict";
+    init_digest();
+    estimateTokens = (tool) => Math.ceil(
+      canonicalJson({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      }).length / 4
+    );
+    formatTokens = (n) => n < 1e3 ? `~${n} tok` : `~${(n / 1e3).toFixed(1)}k tok`;
+    sumTokens = (tools) => {
+      let total = 0;
+      for (const tool of Object.values(tools)) {
+        if (tool.tokens === void 0) return null;
+        total += tool.tokens;
+      }
+      return total;
+    };
+  }
+});
+
 // src/commands/list.ts
 var list_exports = {};
 __export(list_exports, {
@@ -2511,6 +2536,7 @@ var init_list = __esm({
     init_repo();
     init_io();
     init_schema();
+    init_tokens();
     init_local_config();
     init_prompts();
     truncate = (s, max) => {
@@ -2570,6 +2596,7 @@ var init_list = __esm({
                 enabled: !disabled.has(name),
                 detail: serverDetail2.get(name) ?? null,
                 toolCount: entry.tools ? Object.keys(entry.tools).length : null,
+                tokenEstimate: entry.tools ? sumTokens(entry.tools) : null,
                 authRequired: entry.authRequired ?? false
               })),
               plugins: plugins.map(({ name, entry }) => ({
@@ -2619,22 +2646,35 @@ var init_list = __esm({
             return `${n ?? "?"} tools`.length;
           })
         );
+        const tokenCell = (entry) => {
+          const total = entry.tools ? sumTokens(entry.tools) : null;
+          return total === null ? "? tok" : formatTokens(total);
+        };
+        const tokW = Math.max(...mcp.map((e) => tokenCell(e.entry).length));
         lines.push("", `  ${c.bold("mcp servers")}`);
         for (const { name, entry } of mcp) {
           const count = entry.tools ? Object.keys(entry.tools).length : null;
+          const tokenTotal = entry.tools ? sumTokens(entry.tools) : null;
           if (count === null) {
             if (entry.authRequired) needsAuth.push(name);
             else missingTools = true;
+          } else if (tokenTotal === null) {
+            missingTools = true;
           }
           const tools = padCell(
             `${count ?? "?"} tools`,
             toolW,
             count === null ? c.dim : c.green
           );
+          const tokens = padCell(
+            tokenCell(entry),
+            tokW,
+            tokenTotal === null ? c.dim : c.cyan
+          );
           const detail = serverDetail2.get(name);
           const off = disabled.has(name) ? `  ${c.yellow("disabled")}` : "";
           lines.push(
-            `    ${name.padEnd(nameW)} ${entry.transport.padEnd(5)} ${tools}` + (detail ? `  ${c.dim(detail)}` : "") + off
+            `    ${name.padEnd(nameW)} ${entry.transport.padEnd(5)} ${tools}  ${tokens}` + (detail ? `  ${c.dim(detail)}` : "") + off
           );
         }
       }
@@ -2660,7 +2700,173 @@ var init_list = __esm({
         );
       }
       if (missingTools) {
-        lines.push(`  ${c.dim("run 'quiver-cli check' to populate tool counts")}`);
+        lines.push(
+          `  ${c.dim("run 'quiver-cli check' to populate tool counts and token estimates")}`
+        );
+      }
+      lines.push("");
+      block(lines);
+    };
+  }
+});
+
+// src/commands/inspect.ts
+var inspect_exports = {};
+__export(inspect_exports, {
+  inspect: () => inspect
+});
+var truncate2, padCell2, byCost, inspect;
+var init_inspect = __esm({
+  "src/commands/inspect.ts"() {
+    "use strict";
+    init_repo();
+    init_io();
+    init_tokens();
+    init_local_config();
+    init_prompts();
+    truncate2 = (s, max) => {
+      const flat = s.replace(/\s+/g, " ").trim();
+      if (max < 1) return "";
+      return flat.length > max ? flat.slice(0, max - 1) + "\u2026" : flat;
+    };
+    padCell2 = (text, width, color) => color(text.padEnd(width));
+    byCost = (a, b) => (b.tool.tokens ?? -1) - (a.tool.tokens ?? -1) || a.name.localeCompare(b.name);
+    inspect = async (options) => {
+      const arg = options.positionals[0];
+      if (!arg) {
+        if (options.json) {
+          console.log(JSON.stringify({ ok: false, error: "missing-argument" }));
+        } else {
+          await error("Usage: quiver-cli inspect <mcp-name>");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const name = arg.startsWith("mcp:") ? arg.slice("mcp:".length) : arg;
+      const lock = readLockfile(options.targetRoot);
+      if (!lock) {
+        if (options.json) console.log(JSON.stringify({ ok: false, error: "no-lockfile" }));
+        else await error("No quiver.lock found. Run `quiver-cli init` first.");
+        process.exitCode = 1;
+        return;
+      }
+      const entry = lock.entries[`mcp:${name}`];
+      if (!entry || entry.type !== "mcp") {
+        const available = Object.keys(lock.entries).filter((id) => id.startsWith("mcp:")).map((id) => id.slice("mcp:".length)).sort();
+        if (options.json) {
+          console.log(
+            JSON.stringify({ ok: false, error: "unknown-server", available })
+          );
+        } else {
+          await error(
+            `Unknown MCP server "${name}".` + (available.length ? ` Available: ${available.join(", ")}` : "")
+          );
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const mcpEntry = entry;
+      let detail = null;
+      if (repoCatalogExists(options.targetRoot)) {
+        const { catalog } = loadRepoCatalog(options.targetRoot, lock.catalog.source);
+        const cat = catalog.mcp.find((m) => m.name === name);
+        if (cat) {
+          detail = cat.server.transport === "http" ? cat.server.url : [cat.server.command, ...cat.server.args ?? []].join(" ");
+        }
+      }
+      const enabled = !disabledMcpServers(options.targetRoot).has(name);
+      const tools = mcpEntry.tools ? Object.entries(mcpEntry.tools).map(([toolName, tool]) => ({ name: toolName, tool })).sort(byCost) : null;
+      const total = mcpEntry.tools ? sumTokens(mcpEntry.tools) : null;
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              ok: true,
+              name,
+              transport: mcpEntry.transport,
+              detail,
+              enabled,
+              authRequired: mcpEntry.authRequired ?? false,
+              toolsFetchedAt: mcpEntry.toolsFetchedAt,
+              toolCount: tools ? tools.length : null,
+              tokenEstimate: total,
+              tools: tools ? tools.map(({ name: toolName, tool }) => ({
+                name: toolName,
+                description: tool.description,
+                tokens: tool.tokens ?? null,
+                inputSchemaHash: tool.inputSchemaHash
+              })) : null
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      const c = palette();
+      const term = process.stdout.columns ?? 80;
+      const lines = [""];
+      lines.push(
+        `  ${c.bold(name)} ${mcpEntry.transport}` + (detail ? `  ${c.dim(detail)}` : "") + (enabled ? "" : `  ${c.yellow("disabled")}`)
+      );
+      if (!tools) {
+        lines.push("", `  ${c.dim("no tool snapshot recorded yet")}`);
+        if (mcpEntry.authRequired) {
+          lines.push(
+            `  ${c.yellow(`${name} requires OAuth`)} ${c.dim(
+              `\u2014 run 'opencode mcp auth ${name}', then 'quiver-cli check'`
+            )}`
+          );
+        } else {
+          lines.push(`  ${c.dim("run 'quiver-cli check' to introspect this server")}`);
+        }
+        lines.push("");
+        block(lines);
+        return;
+      }
+      const summary = `${tools.length} tools` + (total !== null ? ` \xB7 ${formatTokens(total)}` : "");
+      lines.push(
+        `  ${c.bold(summary)}` + (mcpEntry.toolsFetchedAt ? `  ${c.dim(`snapshot from ${mcpEntry.toolsFetchedAt}`)}` : ""),
+        ""
+      );
+      const nameW = Math.max(...tools.map((t) => t.name.length));
+      const tokW = Math.max(
+        ...tools.map(
+          ({ tool }) => (tool.tokens === void 0 ? "? tok" : formatTokens(tool.tokens)).length
+        )
+      );
+      const descMax = term - (4 + nameW + 2 + tokW + 2) - 1;
+      let missingTokens = false;
+      for (const { name: toolName, tool } of tools) {
+        if (tool.tokens === void 0) missingTokens = true;
+        const tokens = padCell2(
+          tool.tokens === void 0 ? "? tok" : formatTokens(tool.tokens),
+          tokW,
+          tool.tokens === void 0 ? c.dim : c.cyan
+        );
+        if (options.verbose) {
+          lines.push(`    ${c.bold(toolName.padEnd(nameW))}  ${tokens}`);
+          for (const descLine of tool.description.split("\n")) {
+            lines.push(`      ${c.dim(descLine)}`);
+          }
+          lines.push("");
+        } else {
+          lines.push(
+            `    ${toolName.padEnd(nameW)}  ${tokens}  ${c.dim(
+              truncate2(tool.description, descMax)
+            )}`.trimEnd()
+          );
+        }
+      }
+      if (!options.verbose) lines.push("");
+      lines.push(`  ${c.dim("token counts are chars/4 estimates of name + description + input schema")}`);
+      if (!options.verbose) {
+        lines.push(`  ${c.dim("use --verbose for full descriptions")}`);
+      }
+      if (missingTokens) {
+        lines.push(
+          `  ${c.dim("run 'quiver-cli check' to populate missing token estimates")}`
+        );
       }
       lines.push("");
       block(lines);
@@ -2839,21 +3045,34 @@ var init_opencode_auth = __esm({
 });
 
 // src/mcp/snapshot.ts
-var toSnapshot;
+var toSnapshot, backfillTokens;
 var init_snapshot = __esm({
   "src/mcp/snapshot.ts"() {
     "use strict";
     init_digest();
+    init_tokens();
     toSnapshot = (tools) => {
       const snapshot = {};
       for (const tool of tools) {
         snapshot[tool.name] = {
           description: tool.description,
-          inputSchemaHash: jsonDigest(tool.inputSchema)
+          inputSchemaHash: jsonDigest(tool.inputSchema),
+          tokens: estimateTokens(tool)
         };
       }
       return snapshot;
     };
+    backfillTokens = (stored, current) => {
+      let changed = false;
+      for (const [name, tool] of Object.entries(stored)) {
+        const estimate = current[name]?.tokens;
+        if (tool.tokens === void 0 && estimate !== void 0) {
+          tool.tokens = estimate;
+          changed = true;
+        }
+      }
+      return changed;
+    };
   }
 });
 
@@ -2867,7 +3086,7 @@ __export(check_exports, {
 });
 import { accessSync as accessSync2, constants as constants2 } from "fs";
 import { delimiter, resolve as resolve19 } from "path";
-var check, report2, driftLines, list2, recommend, summarize, authHint, hasCommand, truncate2, fail;
+var check, report2, driftLines, list2, recommend, summarize, authHint, hasCommand, truncate3, fail;
 var init_check = __esm({
   "src/commands/check.ts"() {
     "use strict";
@@ -2970,6 +3189,7 @@ var init_check = __esm({
         }
         const diff = diffSnapshots(mcpEntry.tools, current);
         if (isEmptyDiff(diff)) {
+          if (backfillTokens(mcpEntry.tools, current)) lockChanged = true;
           mcpReports.push({ id, status: "ok" });
         } else if (options.accept) {
           mcpEntry.tools = current;
@@ -3086,8 +3306,8 @@ var init_check = __esm({
           for (const d of dc) {
             lines.push(
               `  "${d.name}":
-      before: ${truncate2(d.before)}
-      after:  ${truncate2(d.after)}`
+      before: ${truncate3(d.before)}
+      after:  ${truncate3(d.after)}`
             );
           }
         }
@@ -3151,7 +3371,7 @@ var init_check = __esm({
       }
       return false;
     };
-    truncate2 = (s, max = 120) => s.length > max ? s.slice(0, max) + "\u2026" : s;
+    truncate3 = (s, max = 120) => s.length > max ? s.slice(0, max) + "\u2026" : s;
     fail = async (options, code, message) => {
       if (options.json) console.log(JSON.stringify({ ok: false, error: code }));
       else await error(message);
@@ -3661,6 +3881,7 @@ Commands:
   providers [a,b]  Change which tools get configs (claude, opencode, codex)
   update [id]      Pull newer catalog content into .agents/ (all or one entry)
   list             Show installed entries (skills, commands, plugins, MCP tool counts)
+  inspect <name>   Show an MCP server's tools with descriptions and token cost
   check            Detect drift: skill digests, provider shims, MCP tool
                    snapshots (--offline skips MCP re-introspection)
   upstream         Catalog maintenance: check source repos for skill updates
@@ -3672,8 +3893,9 @@ Commands:
 Options:
   -f, --force          Overwrite existing files
   --all, -y            Keep everything without prompting (non-interactive)
-  --json               Machine-readable output (check/upstream/list)
-  -V, --verbose        Show full tool lists and description diffs (check)
+  --json               Machine-readable output (check/upstream/list/inspect)
+  -V, --verbose        Show full tool lists and description diffs (check);
+                       full tool descriptions (inspect)
   --accept             Record the current MCP tool snapshots as the new baseline (check)
   --offline            Skip MCP re-introspection; check digests + shims only (check)
   --dry-run            Report what would change without writing (update)
@@ -3797,6 +4019,11 @@ var run = async () => {
       await list3(options);
       break;
     }
+    case "inspect": {
+      const { inspect: inspect2 } = await Promise.resolve().then(() => (init_inspect(), inspect_exports));
+      await inspect2(options);
+      break;
+    }
     case "check": {
       const { check: check2 } = await Promise.resolve().then(() => (init_check(), check_exports));
       await check2(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quiver-cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Compose selected skills, commands, plugins and MCP servers from a central catalog into any repo as native configs for opencode, Claude Code and Codex - with lockfile-based drift awareness.",
   "type": "module",
   "bin": {