sigrank 1.0.1 → 1.0.3

package/bin/sigrank.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * Thin command shim for SigRank Standard commands.
+ *
+ * All existing commands and MCP/TUI behavior are delegated to ../index.mjs.
+ * The shim exists so the standard commands can be added without coupling the
+ * large presentation CLI to the standard specification.
+ */
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+const SPEC = "sigrank/0.1-draft";
+const STANDARD_URL = "https://signalaf.com/standard";
+const SCHEMA_URL =
+  "https://signalaf.com/standard/sigrank-operator-record-v0.1.schema.json";
+
+function flag(name, fallback = undefined) {
+  const eq = args.find((a) => a.startsWith(`--${name}=`));
+  if (eq) return eq.slice(name.length + 3);
+  const i = args.indexOf(`--${name}`);
+  if (i >= 0 && i + 1 < args.length && !args[i + 1].startsWith("--")) {
+    return args[i + 1];
+  }
+  return fallback;
+}
+
+function printStandard() {
+  const payload = {
+    spec: SPEC,
+    status: "proposed_open_standard",
+    scope: "human operation of generative AI systems",
+    telemetry: ["input", "output", "cache_write", "cache_read"],
+    metrics: {
+      yield: "(cache_read * output) / input^2",
+      leverage: "cache_read / input",
+      velocity: "output / input",
+      snr: "output / (input + output)",
+      dev10x: "log10(cache_read / input)",
+    },
+    privacy:
+      "Core metrics do not require prompt text, response text, source code, or repository contents.",
+    reference_math: "@sigrank/cascade",
+    reference_platform: "SignalAF",
+    standard_url: STANDARD_URL,
+    schema_url: SCHEMA_URL,
+  };
+
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`SigRank Standard ${SPEC}\n`);
+  process.stdout.write(`The new standard in operator metrics.\n\n`);
+  process.stdout.write(`Scope: ${payload.scope}\n`);
+  process.stdout.write(`Primitives: input / output / cache_write / cache_read\n`);
+  process.stdout.write(`Core metrics: Yield / Leverage / Velocity / SNR / 10xDEV\n`);
+  process.stdout.write(`Reference math: @sigrank/cascade\n`);
+  process.stdout.write(`Reference platform: SignalAF\n`);
+  process.stdout.write(`Spec: ${STANDARD_URL}\n`);
+  process.stdout.write(`Schema: ${SCHEMA_URL}\n`);
+}
+
+async function exportStandardRecord() {
+  const { callTool } = await import("../tools.mjs");
+
+  const platform = flag("platform", "claude");
+  const window = flag("window", "30d");
+
+  const explicit = ["input", "output", "cache-write", "cache-read"].every(
+    (name) => flag(name) !== undefined,
+  );
+
+  let pillars;
+  let sourcePlatform = platform;
+
+  if (explicit) {
+    pillars = {
+      input: Number(flag("input")),
+      output: Number(flag("output")),
+      cache_write: Number(flag("cache-write")),
+      cache_read: Number(flag("cache-read")),
+    };
+  } else {
+    const pulled = await callTool("tokenpull", { platform });
+    const selected = (pulled?.windows || []).find(
+      (w) => w.window === window || (window === "all_time" && w.window === "all"),
+    );
+    if (!selected?.pillars) {
+      throw new Error(
+        `No ${window} telemetry found for ${platform}. Pass --platform/--window or explicit --input --output --cache-write --cache-read.`,
+      );
+    }
+    sourcePlatform = pulled.platform || platform;
+    pillars = {
+      input: selected.pillars.input,
+      output: selected.pillars.output,
+      cache_write: selected.pillars.cacheCreate,
+      cache_read: selected.pillars.cacheRead,
+    };
+  }
+
+  for (const [key, value] of Object.entries(pillars)) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`${key} must be a non-negative finite number.`);
+    }
+  }
+
+  const record = await callTool("get_sigrank_standard_record", {
+    ...pillars,
+    provider: flag("provider", "local"),
+    model: flag("model", "unknown"),
+    tool: flag("tool", sourcePlatform || "sigrank"),
+    timestamp: new Date().toISOString(),
+  });
+
+  record.context = {
+    ...(record.context || {}),
+    window,
+    source_platform: sourcePlatform,
+  };
+
+  process.stdout.write(`${JSON.stringify(record, null, 2)}\n`);
+}
+
+if (cmd === "standard") {
+  printStandard();
+} else if (cmd === "export" && args.includes("--standard")) {
+  exportStandardRecord().catch((err) => {
+    process.stderr.write(`[sigrank] ${err?.message || err}\n`);
+    process.exitCode = 1;
+  });
+} else {
+  await import("../index.mjs");
+}

package/manifest.json

@@ -2,8 +2,8 @@
   "$schema": "https://raw.githubusercontent.com/anthropics/mcpb/main/schemas/mcpb-manifest-v0.4.schema.json",
   "manifest_version": "0.4",
   "name": "sigrank",
-  "version": "1.0.0",
-  "description": "Ranks AI coding operators by token cascade efficiency (Yield = cache_read \u00d7 output / input\u00b2). 23 tools for yield calculation, local token usage pulls, signed submission, and tokscale-powered analytics (market share, developer profiles, model trends, cost analysis, device profiles, MCP usage, competitive intelligence). Privacy-first: runs locally, only four token counts leave the machine.",
+  "version": "1.0.2",
+  "description": "Ranks AI coding operators by token cascade efficiency (Yield = cache_read \u00d7 output / input\u00b2). 25 tools including SigRank Standard record, yield calculation, local token usage pulls, signed submission, and tokscale-powered analytics (market share, developer profiles, model trends, cost analysis, device profiles, MCP usage, competitive intelligence). Privacy-first: runs locally, only four token counts leave the machine.",
   "author": {
     "name": "SunrisesIllNeverSee",
     "url": "https://github.com/SunrisesIllNeverSee"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "description": "SigRank MCP server — AI operator evaluation and token cascade efficiency tools. The yield cascade + live leaderboard as MCP tools any agent can call.",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",
@@ -15,8 +15,8 @@
     "url": "https://github.com/SunrisesIllNeverSee/sigrank-mcp/issues"
   },
   "bin": {
-    "sigrank": "index.mjs",
-    "sigrank-mcp": "index.mjs"
+    "sigrank": "bin/sigrank.mjs",
+    "sigrank-mcp": "bin/sigrank.mjs"
   },
   "main": "index.mjs",
   "engines": {
@@ -24,13 +24,14 @@
   },
   "scripts": {
     "start": "node index.mjs",
-    "test": "node test.mjs && node __tests__/sign.test.mjs && node --test __tests__/cascade.test.mjs __tests__/badges.test.mjs __tests__/tui-input.test.mjs",
+    "test": "node test.mjs && node __tests__/sign.test.mjs && node --test __tests__/cascade.test.mjs __tests__/badges.test.mjs __tests__/tui-input.test.mjs __tests__/standard-record.test.mjs __tests__/standard-cli.test.mjs",
     "sync:platforms": "node scripts/sync-platforms.mjs",
     "sync:spine": "node scripts/sync-spine.mjs",
     "spine:check": "node scripts/sync-spine.mjs --check",
     "spine:diff": "node scripts/sync-spine.mjs --dry-run"
   },
   "files": [
+    "bin/",
     "index.mjs",
     "proxy.mjs",
     "lib/",

package/tools/index.mjs

@@ -15,6 +15,7 @@ import {
 } from "../lib/constants.mjs";
 
 import { TOOL_DEF as rankPasteTool, handleRankPaste } from "./rank-paste.mjs";
+import { TOOL_DEF as standardRecordTool, handleGetSigRankStandardRecord } from "./standard-record.mjs";
 import { TOOL_DEF as getLeaderboardTool, handleGetLeaderboard } from "./get-leaderboard.mjs";
 import { TOOL_DEF as getOperatorTool, handleGetOperator } from "./get-operator.mjs";
 import { TOOL_DEF as submitPasteTool, handleSubmitPaste } from "./submit-paste.mjs";
@@ -48,6 +49,7 @@ export { DEFAULT_API_BASE, DEFAULT_FETCH_TIMEOUT };
 
 export const TOOLS = [
   rankPasteTool,
+  standardRecordTool,
   getLeaderboardTool,
   getOperatorTool,
   submitPasteTool,
@@ -175,6 +177,8 @@ export async function callTool(name, args, opts = {}) {
   switch (name) {
     case "rank_paste":
       return handleRankPaste(args);
+    case "get_sigrank_standard_record":
+      return handleGetSigRankStandardRecord(args);
     case "get_leaderboard":
       return handleGetLeaderboard(args, ctx);
     case "get_operator":

package/tools/standard-record.mjs

@@ -0,0 +1,108 @@
+import { cascade } from "../analytics/cascade.mjs";
+import { ANNOTATIONS } from "./_schemas.mjs";
+
+export const SIGRANK_STANDARD_VERSION = "sigrank/0.1-draft";
+
+export const TOOL_DEF = {
+  name: "get_sigrank_standard_record",
+  description:
+    "Build a SigRank Standard v0.1-draft portable operator record from four token pillars. Computes the canonical cascade locally through @sigrank/cascade and returns versioned telemetry plus the normative core metrics: Yield, Leverage, Velocity, SNR, and 10xDEV. No data is submitted or persisted. The core record contains token telemetry only and does not require prompt text, code, or response content.",
+  annotations: {
+    title: "Export SigRank standard record",
+    ...ANNOTATIONS.readOnlyHint,
+    ...ANNOTATIONS.destructiveHint,
+    ...ANNOTATIONS.idempotentHint,
+    ...ANNOTATIONS.openWorldHint,
+  },
+  inputSchema: {
+    type: "object",
+    additionalProperties: false,
+    required: ["input", "output", "cache_write", "cache_read"],
+    properties: {
+      input: { type: "number", minimum: 0, description: "Fresh input tokens." },
+      output: { type: "number", minimum: 0, description: "Output tokens." },
+      cache_write: { type: "number", minimum: 0, description: "Cache-write / cache-creation tokens." },
+      cache_read: { type: "number", minimum: 0, description: "Cache-read tokens." },
+      provider: { type: "string", description: "Optional provider identifier." },
+      model: { type: "string", description: "Optional model identifier." },
+      tool: { type: "string", description: "Optional tool/client identifier." },
+      timestamp: { type: "string", description: "Optional ISO-8601 timestamp. Defaults to the current time." }
+    }
+  },
+  outputSchema: {
+    type: "object",
+    required: ["spec", "timestamp", "source", "telemetry", "metrics"],
+    properties: {
+      spec: { type: "string", description: "SigRank specification version." },
+      timestamp: { type: "string", description: "ISO-8601 record timestamp." },
+      source: {
+        type: "object",
+        properties: {
+          provider: { type: "string" },
+          model: { type: "string" },
+          tool: { type: "string" }
+        }
+      },
+      telemetry: {
+        type: "object",
+        properties: {
+          input: { type: "number" },
+          output: { type: "number" },
+          cache_write: { type: "number" },
+          cache_read: { type: "number" }
+        }
+      },
+      metrics: {
+        type: "object",
+        properties: {
+          yield: { type: ["number", "null"] },
+          leverage: { type: ["number", "null"] },
+          velocity: { type: ["number", "null"] },
+          snr: { type: ["number", "null"] },
+          dev10x: { type: ["number", "null"] }
+        }
+      },
+      warnings: { type: "array", items: { type: "string" } }
+    }
+  }
+};
+
+export async function handleGetSigRankStandardRecord(args) {
+  const input = Number(args?.input);
+  const output = Number(args?.output);
+  const cacheWrite = Number(args?.cache_write);
+  const cacheRead = Number(args?.cache_read);
+
+  if (![input, output, cacheWrite, cacheRead].every(Number.isFinite)) {
+    throw new Error("get_sigrank_standard_record requires four finite numeric token pillars.");
+  }
+  if ([input, output, cacheWrite, cacheRead].some((v) => v < 0)) {
+    throw new Error("get_sigrank_standard_record requires non-negative token pillars.");
+  }
+
+  const c = cascade({ input, output, cacheCreate: cacheWrite, cacheRead });
+
+  return {
+    spec: SIGRANK_STANDARD_VERSION,
+    timestamp: args?.timestamp || new Date().toISOString(),
+    source: {
+      provider: args?.provider || "unknown",
+      model: args?.model || "unknown",
+      tool: args?.tool || "sigrank-mcp",
+    },
+    telemetry: {
+      input,
+      output,
+      cache_write: cacheWrite,
+      cache_read: cacheRead,
+    },
+    metrics: {
+      yield: c.yield,
+      leverage: c.leverage,
+      velocity: c.velocity,
+      snr: c.snr,
+      dev10x: c.dev10x,
+    },
+    warnings: c.warnings || [],
+  };
+}