sigrank 0.18.2 → 0.18.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",

package/tools.mjs

@@ -1362,6 +1362,36 @@ export const TOOLS = [
       },
     },
   },
+  {
+    name: "tokscale_breakdown",
+    description:
+      "Show a per-model breakdown of your token usage across all platforms detected by tokscale. Models under the threshold (default 1%) are lumped into 'other' to keep the display clean. Useful for seeing which models you actually use per platform (e.g. claude-opus-4-8 76%, claude-sonnet-4-6 11%, other 0.3%). Returns { platform: [{ model, input, output, cacheRead, cacheCreate, pct }] }.",
+    annotations: {
+      title: "Model breakdown",
+      ...ANNOTATIONS.readOnlyHint,
+      ...ANNOTATIONS.openWorldHint,
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        threshold: {
+          type: "number",
+          description:
+            "Models below this fraction of their platform's total tokens are lumped into 'other'. Default 0.01 (1%). Set 0 to see every model.",
+          default: 0.01,
+        },
+      },
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        platforms: {
+          type: "object",
+          description: "Map of platform name → array of { model, input, output, cacheRead, cacheCreate, pct }",
+        },
+      },
+    },
+  },
 ];
 
 // tokenpull window key → the board's window_type enum.
@@ -1383,9 +1413,191 @@ const _lastWatchSubmitAt = new Map();
 // keeps only platforms with real local data, and sorts claude → codex → rest.
 // Pass `platforms` to scope it (e.g. ['claude'] for a fast first paint).
 export async function pullActivePlatforms({ platforms } = {}, opts = {}) {
-  const targets = platforms && platforms.length ? platforms : ALL_PLATFORMS;
+  // If the caller specified explicit platforms, use those.
+  if (platforms && platforms.length) {
+    return _pullExplicit(platforms, opts);
+  }
+  // Auto-detect: run tokscale once to discover all active clients, then pull
+  // only those. This is much faster than trying all 17 adapters (most fail
+  // silently on a machine that doesn't have that tool installed).
+  //
+  // Flow: tokscale surfaces ALL clients → map to our platform names →
+  // ccusage is primary for Claude (more accurate) → other platforms use
+  // their adapters. Anything in tokscale NOT in ccusage gets included.
+  const detected = await _tokscaleDetectClients().catch(() => null);
+  if (detected && detected.length > 0) {
+    return _pullExplicit(detected, opts);
+  }
+  // Fallback: tokscale not installed or failed → try all adapters (old behavior)
+  return _pullExplicit(ALL_PLATFORMS, opts);
+}
+
+/** Run `tokscale models --json` and return the list of our platform names. */
+async function _tokscaleDetectClients() {
+  const raw = await execFileAsync("tokscale", ["models", "--json"], 60000);
+  const data = JSON.parse(raw);
+  const entries = Array.isArray(data?.entries)
+    ? data.entries
+    : Array.isArray(data)
+      ? data
+      : [];
+  if (!entries.length) return [];
+  // Complete tokscale client → our platform name mapping.
+  // Tokscale supports 40 clients (as of v3.1.0). We have native adapters for 16;
+  // the rest map to "other" (user-supplied JSON via SIGRANK_OTHER_PATH).
+  // Source: https://github.com/junhoyeo/tokscale
+  const TOKSCALE_CLIENT_MAP = {
+    // Native adapters
+    claude: "claude",
+    codex: "codex",
+    "devin-cli": "devin",
+    "devin-desktop": "devin",
+    gemini: "gemini",
+    amp: "amp",
+    kimi: "kimi",
+    qwen: "qwen",
+    goose: "goose",
+    kilo: "kilo",
+    kilocode: "kilo",
+    hermes: "hermes",
+    droid: "droid",
+    codebuff: "codebuff",
+    copilot: "copilot",
+    opencode: "opencode",
+    openclaw: "openclaw",
+    pi: "pi",
+    // No native adapter yet → "other"
+    cursor: "other",
+    roocode: "other",
+    mux: "other",
+    crush: "other",
+    antigravity: "other",
+    "antigravity-cli": "other",
+    zed: "other",
+    kiro: "other",
+    trae: "other",
+    warp: "other",
+    cline: "other",
+    gjc: "other",
+    grok: "other",
+    jcode: "other",
+    commandcode: "other",
+    micode: "other",
+    junie: "other",
+    zcode: "other",
+    opencodereview: "other",
+    codebuddy: "other",
+    workbuddy: "other",
+    // synthetic = re-attributed from other sources, skip
+    synthetic: null,
+  };
+  const clients = new Set();
+  for (const e of entries) {
+    if (!e || !e.client) continue;
+    if (e.model === "<synthetic>" || e.model === "unknown") continue;
+    const input = Number(e.input) || 0;
+    const output = Number(e.output) || 0;
+    if (input + output === 0) continue;
+    const platform = TOKSCALE_CLIENT_MAP[e.client];
+    if (platform === null) continue; // synthetic → skip
+    clients.add(platform || "other");
+  }
+  return [...clients];
+}
+
+/**
+ * Run `tokscale models --json` and return a model-level breakdown per platform.
+ * Models under `threshold` (default 1%) of their platform's total are lumped
+ * into "other" to keep the display clean.
+ *
+ * Returns: { platform: [{ model, input, output, cacheRead, cacheCreate, pct }] }
+ */
+export async function tokscaleModelBreakdown(threshold = 0.01) {
+  const raw = await execFileAsync("tokscale", ["models", "--json"], 60000);
+  const data = JSON.parse(raw);
+  const entries = Array.isArray(data?.entries)
+    ? data.entries
+    : Array.isArray(data)
+      ? data
+      : [];
+  if (!entries.length) return {};
+
+  const TOKSCALE_CLIENT_MAP = {
+    claude: "claude", codex: "codex", "devin-cli": "devin",
+    "devin-desktop": "devin", gemini: "gemini", amp: "amp",
+    kimi: "kimi", qwen: "qwen", goose: "goose", kilo: "kilo",
+    kilocode: "kilo", hermes: "hermes", droid: "droid",
+    codebuff: "codebuff", copilot: "copilot", opencode: "opencode",
+    openclaw: "openclaw", pi: "pi",
+    cursor: "other", roocode: "other", mux: "other", crush: "other",
+    antigravity: "other", "antigravity-cli": "other", zed: "other",
+    kiro: "other", trae: "other", warp: "other", cline: "other",
+    gjc: "other", grok: "other", jcode: "other", commandcode: "other",
+    micode: "other", junie: "other", zcode: "other",
+    opencodereview: "other", codebuddy: "other", workbuddy: "other",
+    synthetic: null,
+  };
+
+  // Group entries by our platform name
+  const byPlatform = {};
+  for (const e of entries) {
+    if (!e || !e.client) continue;
+    if (e.model === "<synthetic>" || e.model === "unknown") continue;
+    const input = Number(e.input) || 0;
+    const output = Number(e.output) || 0;
+    if (input + output === 0) continue;
+    const platform = TOKSCALE_CLIENT_MAP[e.client];
+    if (platform === null) continue;
+    const p = platform || "other";
+    if (!byPlatform[p]) byPlatform[p] = [];
+    byPlatform[p].push({
+      model: e.model,
+      input,
+      output,
+      cacheRead: Number(e.cacheRead) || 0,
+      cacheCreate: Number(e.cacheWrite) || 0,
+    });
+  }
+
+  // For each platform: sort by total tokens desc, lump small models into "other"
+  const result = {};
+  for (const [platform, models] of Object.entries(byPlatform)) {
+    const total = models.reduce(
+      (s, m) => s + m.input + m.output + m.cacheRead + m.cacheCreate,
+      0,
+    );
+    if (total === 0) continue;
+    const sorted = models.sort(
+      (a, b) =>
+        b.input + b.output + b.cacheRead + b.cacheCreate -
+        (a.input + a.output + a.cacheRead + a.cacheCreate),
+    );
+    const big = [];
+    const small = { model: "other", input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+    for (const m of sorted) {
+      const t = m.input + m.output + m.cacheRead + m.cacheCreate;
+      if (t / total < threshold) {
+        small.input += m.input;
+        small.output += m.output;
+        small.cacheRead += m.cacheRead;
+        small.cacheCreate += m.cacheCreate;
+      } else {
+        big.push({ ...m, pct: t / total });
+      }
+    }
+    if (small.input + small.output + small.cacheRead + small.cacheCreate > 0) {
+      const t = small.input + small.output + small.cacheRead + small.cacheCreate;
+      big.push({ ...small, pct: t / total });
+    }
+    result[platform] = big;
+  }
+  return result;
+}
+
+/** Pull a specific set of platforms in parallel, filter to active ones. */
+async function _pullExplicit(platforms, opts = {}) {
   const settled = await Promise.allSettled(
-    targets.map((p) => callTool("tokenpull", { platform: p }, opts)),
+    platforms.map((p) => callTool("tokenpull", { platform: p }, opts)),
   );
   const active = settled
     .filter((r) => r.status === "fulfilled" && r.value)
@@ -3290,6 +3502,12 @@ export async function callTool(name, args, opts = {}) {
     };
   }
 
+  if (name === "tokscale_breakdown") {
+    const threshold = Number(args?.threshold ?? 0.01);
+    const platforms = await tokscaleModelBreakdown(threshold);
+    return { platforms };
+  }
+
   throw new Error(`Unknown tool: ${name}`);
 }