@tokenzero/cli 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/bin/tokenzero.mjs

@@ -0,0 +1,903 @@
+#!/usr/bin/env node
+// TokenZero CLI (generated by cli/build.mjs; do not edit)
+
+// cli/src/main.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import crypto2 from "node:crypto";
+import readline from "node:readline/promises";
+
+// src/audit-core.ts
+import crypto from "node:crypto";
+
+// src/pricing.ts
+var P = (provider, tier, input, output, cachedInput, cacheWrite, extra = {}) => ({ provider, tier, input, output, cachedInput, cacheWrite, ...extra });
+var PRICES = {
+  // ---- OpenAI (standard tier, ≤272K; cache write = 30m TTL rate) ----
+  "gpt-6-astra": P("openai", "frontier", 10, 50, 1, 12.5, { longCtxAt: 272e3, longCtx: { input: 20, output: 75, cachedInput: 2, cacheWrite: 25 }, minCacheTokens: 1024 }),
+  "gpt-6.1-sol": P("openai", "mid", 2, 10, 0.1, 2.5, { longCtxAt: 272e3, longCtx: { input: 4, output: 15, cachedInput: 0.2, cacheWrite: 5 }, minCacheTokens: 1024 }),
+  "gpt-6-sol": P("openai", "mid", 2, 10, 0.2, 2.5, { longCtxAt: 272e3, longCtx: { input: 4, output: 15, cachedInput: 0.4, cacheWrite: 5 }, minCacheTokens: 1024 }),
+  "gpt-6-luna": P("openai", "fast", 0.1, 0.5, 0.01, 0.125, { longCtxAt: 272e3, longCtx: { input: 0.2, output: 0.75, cachedInput: 0.02, cacheWrite: 0.25 }, minCacheTokens: 1024 }),
+  "gpt-5.6-sol": P("openai", "frontier", 4, 20, 0.4, 5, { longCtxAt: 272e3, longCtx: { input: 8, output: 30, cachedInput: 0.8, cacheWrite: 10 }, minCacheTokens: 1024 }),
+  "gpt-5.6-terra": P("openai", "mid", 2, 12, 0.2, 2.5, { longCtxAt: 272e3, longCtx: { input: 4, output: 18, cachedInput: 0.4, cacheWrite: 5 }, minCacheTokens: 1024 }),
+  "gpt-5.6-luna": P("openai", "fast", 0.2, 1.2, 0.02, 0.25, { longCtxAt: 272e3, longCtx: { input: 0.4, output: 1.8, cachedInput: 0.04, cacheWrite: 0.5 }, minCacheTokens: 1024 }),
+  "gpt-5.5": P("openai", "frontier", 5, 30, 0.5, void 0, { longCtxAt: 272e3, longCtx: { input: 10, output: 45, cachedInput: 1 }, minCacheTokens: 1024 }),
+  "gpt-5.5-pro": P("openai", "frontier", 30, 180),
+  "gpt-5.4": P("openai", "frontier", 2.5, 15, 0.25, void 0, { longCtxAt: 272e3, longCtx: { input: 5, output: 22.5, cachedInput: 0.5 }, minCacheTokens: 1024 }),
+  "gpt-5.4-pro": P("openai", "frontier", 30, 180),
+  "gpt-5.4-mini": P("openai", "fast", 0.75, 4.5, 0.075, void 0, { minCacheTokens: 1024 }),
+  "gpt-5.4-nano": P("openai", "fast", 0.2, 1.25, 0.02, void 0, { minCacheTokens: 1024 }),
+  "gpt-5.2": P("openai", "frontier", 1.75, 14, 0.175, void 0, { minCacheTokens: 1024 }),
+  "gpt-5.2-pro": P("openai", "frontier", 21, 168),
+  "gpt-5.1": P("openai", "mid", 1.25, 10, 0.125, void 0, { minCacheTokens: 1024 }),
+  "gpt-5": P("openai", "mid", 1.25, 10, 0.125, void 0, { minCacheTokens: 1024 }),
+  "gpt-5-mini": P("openai", "fast", 0.25, 2, 0.025, void 0, { minCacheTokens: 1024 }),
+  "gpt-5-nano": P("openai", "fast", 0.05, 0.4, 5e-3, void 0, { minCacheTokens: 1024 }),
+  "gpt-5-pro": P("openai", "frontier", 15, 120),
+  "o3": P("openai", "mid", 2, 8, 0.5, void 0, { minCacheTokens: 1024 }),
+  "o3-pro": P("openai", "frontier", 20, 80),
+  "o3-mini": P("openai", "fast", 1.1, 4.4, 0.55, void 0, { minCacheTokens: 1024 }),
+  "o4-mini": P("openai", "fast", 1.1, 4.4, 0.275, void 0, { minCacheTokens: 1024 }),
+  "o1": P("openai", "frontier", 15, 60, 7.5),
+  "gpt-4.1": P("openai", "mid", 2, 8, 0.5, void 0, { minCacheTokens: 1024 }),
+  "gpt-4.1-mini": P("openai", "fast", 0.4, 1.6, 0.1, void 0, { minCacheTokens: 1024 }),
+  "gpt-4.1-nano": P("openai", "fast", 0.1, 0.4, 0.025, void 0, { minCacheTokens: 1024 }),
+  "gpt-4o": P("openai", "mid", 2.5, 10, 1.25, void 0, { minCacheTokens: 1024 }),
+  "gpt-4o-mini": P("openai", "fast", 0.15, 0.6, 0.075, void 0, { minCacheTokens: 1024 }),
+  // ---- Anthropic (cache write = 5-minute TTL, 1.25x; 1h TTL is 2x) ----
+  "claude-fable-5-1": P("anthropic", "frontier", 10, 50, 0.25, 12.5, { minCacheTokens: 512 }),
+  "claude-fable-5": P("anthropic", "frontier", 10, 50, 1, 12.5, { minCacheTokens: 512 }),
+  "claude-opus-5-5": P("anthropic", "frontier", 4, 20, 0.2, 5, { minCacheTokens: 512 }),
+  "claude-opus-5": P("anthropic", "frontier", 5, 25, 0.5, 6.25, { minCacheTokens: 512 }),
+  "claude-opus-4-8": P("anthropic", "frontier", 5, 25, 0.5, 6.25, { minCacheTokens: 1024 }),
+  "claude-opus-4-7": P("anthropic", "frontier", 5, 25, 0.5, 6.25, { minCacheTokens: 2048 }),
+  "claude-opus-4-6": P("anthropic", "frontier", 5, 25, 0.5, 6.25, { minCacheTokens: 4096 }),
+  "claude-opus-4-5": P("anthropic", "frontier", 5, 25, 0.5, 6.25, { minCacheTokens: 4096 }),
+  "claude-sonnet-5-5": P("anthropic", "mid", 2, 10, 0.2, 2.5, { minCacheTokens: 512 }),
+  "claude-sonnet-5": P("anthropic", "mid", 2, 10, 0.2, 2.5, { minCacheTokens: 1024 }),
+  "claude-sonnet-4-6": P("anthropic", "mid", 3, 15, 0.3, 3.75, { minCacheTokens: 1024 }),
+  "claude-sonnet-4-5": P("anthropic", "mid", 3, 15, 0.3, 3.75, { minCacheTokens: 1024 }),
+  "claude-haiku-5-5": P("anthropic", "fast", 0.1, 0.5, 0.01, 0.125, { minCacheTokens: 512, longCtxAt: 1e5, longCtx: { input: 0.5, output: 2.5, cachedInput: 0.05, cacheWrite: 0.625 } }),
+  "claude-haiku-4-5": P("anthropic", "fast", 1, 5, 0.1, 1.25, { minCacheTokens: 4096 }),
+  // ---- Google Gemini (paid tier; prices scheduled to rise Dec 2026/Jan 2027 — re-verify) ----
+  "gemini-4-argon": P("gemini", "frontier", 2, 10, 0.1),
+  "gemini-3.8-flash": P("gemini", "fast", 0.75, 3.75, 0.075),
+  "gemini-3.6-flash": P("gemini", "fast", 0.75, 3.75, 0.075),
+  "gemini-3.5-flash-lite": P("gemini", "fast", 0.3, 2.5, 0.03),
+  "gemini-3.1-pro": P("gemini", "frontier", 2, 12, 0.2, void 0, { longCtxAt: 2e5, longCtx: { input: 4, output: 18, cachedInput: 0.4 } }),
+  "gemini-3.1-flash-lite": P("gemini", "fast", 0.25, 1.5, 0.025),
+  "gemini-3-flash": P("gemini", "fast", 0.5, 3, 0.05),
+  "gemini-2.5-pro": P("gemini", "frontier", 1.25, 10, 0.125, void 0, { longCtxAt: 2e5, longCtx: { input: 2.5, output: 15, cachedInput: 0.25 } }),
+  "gemini-2.5-flash": P("gemini", "fast", 0.3, 2.5, 0.03),
+  "gemini-2.5-flash-lite": P("gemini", "fast", 0.1, 0.4, 0.01)
+};
+var CASCADE_TARGET = {
+  "gpt-6-astra": "gpt-6.1-sol",
+  "gpt-6.1-sol": "gpt-6-luna",
+  "gpt-6-sol": "gpt-6-luna",
+  "gpt-5.6-sol": "gpt-5.6-terra",
+  "gpt-5.6-terra": "gpt-5.6-luna",
+  "gpt-5.5": "gpt-5.4-mini",
+  "gpt-5.4": "gpt-5.4-mini",
+  "gpt-5.2": "gpt-5-mini",
+  "gpt-5.1": "gpt-5-mini",
+  "gpt-5": "gpt-5-mini",
+  "gpt-4.1": "gpt-4.1-mini",
+  "gpt-4o": "gpt-4o-mini",
+  "o3": "o4-mini",
+  "claude-fable-5-1": "claude-opus-5-5",
+  "claude-fable-5": "claude-opus-5-5",
+  "claude-opus-5-5": "claude-sonnet-5-5",
+  "claude-opus-5": "claude-sonnet-5-5",
+  "claude-opus-4-8": "claude-sonnet-5-5",
+  "claude-opus-4-7": "claude-sonnet-5-5",
+  "claude-opus-4-6": "claude-sonnet-4-6",
+  "claude-sonnet-5-5": "claude-haiku-5-5",
+  "claude-sonnet-5": "claude-haiku-5-5",
+  "claude-sonnet-4-6": "claude-haiku-4-5",
+  "claude-sonnet-4-5": "claude-haiku-4-5",
+  "gemini-4-argon": "gemini-3.8-flash",
+  "gemini-3.1-pro": "gemini-3.8-flash",
+  "gemini-3.8-flash": "gemini-3.5-flash-lite",
+  "gemini-2.5-pro": "gemini-2.5-flash",
+  "gemini-2.5-flash": "gemini-2.5-flash-lite"
+};
+var KEYS_BY_LENGTH = Object.keys(PRICES).sort((a, b) => b.length - a.length);
+function normalizeModel(model) {
+  if (typeof model !== "string" || !model) return null;
+  let m = model.toLowerCase().trim();
+  m = m.replace(/^(openai|anthropic|google|models|vertex_ai)\//, "");
+  m = m.replace(/@\d{8}$/, "");
+  m = m.replace(/-(\d{8}|\d{4}-\d{2}-\d{2})$/, "");
+  m = m.replace(/-(latest|preview|customtools|thinking)$/, "");
+  if (PRICES[m]) return m;
+  for (const k of KEYS_BY_LENGTH) if (m.startsWith(k + "-") || m === k) return k;
+  return null;
+}
+function priceFor(model) {
+  const key = normalizeModel(model);
+  return key ? { key, ...PRICES[key] } : null;
+}
+function costOf(model, u) {
+  const p = priceFor(model);
+  if (!p) return null;
+  const tier = p.longCtx && p.longCtxAt && u.input > p.longCtxAt ? { ...p, ...p.longCtx } : p;
+  const cached = u.cachedInput ?? 0;
+  const written = u.cacheWrite ?? 0;
+  const fresh = Math.max(0, u.input - cached - written);
+  const M = 1e6;
+  return fresh * tier.input / M + cached * (tier.cachedInput ?? tier.input) / M + written * (tier.cacheWrite ?? tier.input) / M + u.output * tier.output / M;
+}
+
+// cli/src/tokens-lite.ts
+function countTokens(text, _provider = "openai") {
+  if (!text) return 0;
+  const symbols = (text.match(/[{}[\]<>=;:(),"'`]/g) ?? []).length;
+  const cpt = symbols / text.length > 0.04 ? 3.2 : 4;
+  return Math.ceil(text.length / cpt);
+}
+
+// src/audit-core.ts
+var MODEL_RE = /["'`](?:openai\/|anthropic\/|google\/|models\/)?((?:gpt-[\w.-]+|o[134](?:-mini|-pro)?(?:-[\w-]+)?|claude-[\w.-]+|gemini-[\w.-]+))["'`]/g;
+var CALL_RE = [
+  [/\.chat\.completions\.(create|parse)\s*\(/, "openai-chat"],
+  [/\.responses\.(create|parse|stream)\s*\(/, "openai-responses"],
+  [/\.messages\.(create|stream|parse)\s*\(/, "anthropic-messages"],
+  [/\b(generateText|streamText|generateObject|streamObject)\s*\(/, "vercel-ai"],
+  [/\b(ChatOpenAI|AzureChatOpenAI)\s*\(/, "langchain-openai"],
+  [/\bChatAnthropic\s*\(/, "langchain-anthropic"],
+  [/\bChatGoogleGenerativeAI\s*\(/, "langchain-gemini"],
+  [/\binit_chat_model\s*\(/, "langchain"],
+  [/\.generate_content\s*\(|\.generateContent\s*\(/, "gemini-sdk"],
+  [/\blitellm\.(a?completion)\s*\(/, "litellm"]
+];
+var SOURCE_EXT = /\.(py|ts|tsx|js|jsx|mjs|cjs|rb|go|java|kt|rs|cs|php)$/i;
+var SKIP_PATH = /(^|\/)(node_modules|dist|build|\.next|vendor|venv|\.venv|__pycache__|target|coverage|\.git)(\/|$)|\.min\.js$|\.lock$|\.d\.ts$|(^|\/)(test|tests|__tests__|spec)(\/|$)|[._-](test|spec)\.[a-z]+$|(^|\/)(public|static|assets)\/.*\.m?js$|(^|\/)(workbox|sw|service-worker)[\w.-]*\.js$|[.-][a-f0-9]{8,}\.m?js$|\.bundle\.m?js$/i;
+var EXAMPLE_PATH = /(^|\/)(examples?|docs?|cookbooks?|samples?|demos?|notebooks?|benchmarks?|scripts)(\/|$)/i;
+var MANIFEST_FILES = ["package.json", "pyproject.toml", "setup.py", "setup.cfg"];
+var TRIPLE_DQ = '"'.repeat(3);
+var TRIPLE_SQ = "'".repeat(3);
+function lex(src, path3) {
+  const py = /\.py$/i.test(path3), hashComments = py || /\.(rb|php)$/i.test(path3);
+  const backtick = /\.(js|jsx|ts|tsx|mjs|cjs|go)$/i.test(path3);
+  const out2 = src.split("");
+  const literals = [];
+  let i = 0, line = 1;
+  const blank = (a, b) => {
+    for (let k = a; k < b; k++) if (out2[k] !== "\n") out2[k] = " ";
+  };
+  const advance = (a, b) => {
+    for (let k = a; k < b; k++) if (src[k] === "\n") line++;
+  };
+  while (i < src.length) {
+    const c2 = src[i], two = src.slice(i, i + 2), three = src.slice(i, i + 3);
+    if (hashComments && c2 === "#" || !py && two === "//") {
+      let j = src.indexOf("\n", i);
+      if (j < 0) j = src.length;
+      blank(i, j);
+      i = j;
+      continue;
+    }
+    if (!py && two === "/*") {
+      let j = src.indexOf("*/", i + 2);
+      j = j < 0 ? src.length : j + 2;
+      blank(i, j);
+      advance(i, j);
+      i = j;
+      continue;
+    }
+    if (py && (three === TRIPLE_DQ || three === TRIPLE_SQ)) {
+      let j = src.indexOf(three, i + 3);
+      j = j < 0 ? src.length : j + 3;
+      literals.push({ text: src.slice(i + 3, Math.max(i + 3, j - 3)), line });
+      blank(i + 3, Math.max(i + 3, j - 3));
+      advance(i, j);
+      i = j;
+      continue;
+    }
+    if (c2 === '"' || c2 === "'" || backtick && c2 === "`") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== c2) {
+        if (src[j] === "\\") j++;
+        else if (src[j] === "\n" && c2 !== "`") break;
+        j++;
+      }
+      const end = Math.min(j, src.length);
+      literals.push({ text: src.slice(i + 1, end), line });
+      blank(i + 1, end);
+      advance(i, end + 1);
+      i = end + 1;
+      continue;
+    }
+    if (c2 === "\n") line++;
+    i++;
+  }
+  return { masked: out2.join("").split("\n"), literals };
+}
+function promptLike(t) {
+  if (t.length < 200) return false;
+  const tags = (t.match(/<\/?[a-z][\w-]*[^>]*>/gi) ?? []).length;
+  const cssRules = (t.match(/[{;]\s*[a-z-]+\s*:\s*[^;{}]+;/gi) ?? []).length;
+  const codeChars = (t.match(/[{}();=<>]/g) ?? []).length;
+  const words = (t.match(/[A-Za-z]{2,}/g) ?? []).length;
+  return tags < 4 && cssRules < 3 && codeChars / t.length < 0.03 && words / (t.length / 6) > 0.5;
+}
+var SIMPLE_TASK = /\b(classify|classification|categori[sz]e|sentiment|extract (the|all|every|any)|return (only |just )?(valid |a )?json|respond (only )?(with|in) (valid )?json|output (only )?(valid )?json|translate (this|the following|into)|summari[sz]e (this|the following|in \d+)|label (this|the|each)|is (this|it) spam|yes or no|true or false)\b/i;
+var LLM_LIB_EXACT = /* @__PURE__ */ new Set(["openai", "anthropic", "@anthropic-ai/sdk", "ai", "litellm", "openai-agents", "@openai/agents", "instructor", "dspy", "dspy-ai", "guidance", "semantic-kernel", "haystack-ai", "autogen", "pyautogen", "autogen-agentchat", "crewai", "google-genai", "@google/genai", "mistralai", "@mistralai/mistralai", "cohere", "cohere-ai", "llama-index", "llama_index", "llamaindex", "langchain", "langgraph", "@langchain/core", "groq-sdk", "together-ai", "ollama"]);
+var LLM_LIB_FAMILY = /^(@langchain\/[\w-]+|langchain[-_][\w-]+|langgraph[-_][\w-]+|llama[-_]index[-_][\w-]+|@ai-sdk\/[\w-]+|openai[-_]agents[-_][\w-]+)$/i;
+var isLlmLib = (name) => LLM_LIB_EXACT.has(name.toLowerCase()) || LLM_LIB_FAMILY.test(name);
+var APP_DEPS = ["next", "react-dom", "express", "fastify", "hono", "@remix-run/react", "nuxt", "svelte", "@sveltejs/kit", "electron"];
+function detectRepoKind(manifests2, files) {
+  const get = (n) => manifests2.find((m) => m.path === n)?.content ?? "";
+  const pkgRaw = get("package.json");
+  if (pkgRaw) {
+    try {
+      const pkg = JSON.parse(pkgRaw);
+      if (pkg.name && isLlmLib(pkg.name)) return { kind: "library", reason: `package "${pkg.name}" is an LLM SDK/framework` };
+      const deps = { ...pkg.dependencies };
+      const appDep = APP_DEPS.some((d) => d in deps);
+      const publishable = !pkg.private && (pkg.exports || pkg.main || pkg.module || pkg.types) && (pkg.files || pkg.publishConfig);
+      if (publishable && !appDep) return { kind: "library", reason: "publishable npm package layout (exports/main + files, not private)" };
+      if (pkg.private || appDep) return { kind: "app", reason: "private package or app framework dependency" };
+    } catch {
+    }
+  }
+  const pyproject = get("pyproject.toml"), setup = get("setup.py") + get("setup.cfg");
+  const pyName = /^\s*name\s*=\s*["']([^"']+)["']/m.exec(pyproject)?.[1] ?? /name\s*=\s*["']([^"']+)["']/.exec(setup)?.[1];
+  if (pyName && isLlmLib(pyName)) return { kind: "library", reason: `Python package "${pyName}" is an LLM SDK/framework` };
+  const webApp = files.some((f) => /(^|\/)app\/(layout|page)\.[jt]sx?$|(^|\/)pages\/(_app|index)\.[jt]sx?$|(^|\/)src\/routes\/\+page\.svelte$/.test(f.path));
+  const hasAppEntry = files.some((f) => /^(app|main|server|manage|streamlit_app|bot)\.py$/i.test(f.path) || /^(app|api|server)\//i.test(f.path) && /\b(FastAPI|Flask|Django|streamlit|gradio)\b/.test(f.content));
+  const installable = pyproject.includes("[build-system]") && /^\s*\[project\]/m.test(pyproject) || /\bsetup\(/.test(setup);
+  if (webApp) return { kind: "app", reason: "web app routes found (Next.js / SvelteKit)" };
+  if (installable && files.some((f) => /^src\/[\w-]+\//.test(f.path)) && !hasAppEntry) return { kind: "library", reason: "installable Python package with src/ layout and no app entry point" };
+  if (hasAppEntry) return { kind: "app", reason: "app entry point found" };
+  return { kind: "unknown", reason: "no manifest signal" };
+}
+var DOWN = { high: "medium", medium: "low", low: "info", info: "info" };
+function analyzeFiles(files, repo = null, manifests2 = []) {
+  const findings = [];
+  const callSites = [];
+  const siteFindings = [];
+  const models = {};
+  const unknownModels = /* @__PURE__ */ new Set();
+  const notes = [];
+  const sources = files.filter((f) => SOURCE_EXT.test(f.path) && !SKIP_PATH.test(f.path) && f.content.length <= 4e5);
+  const { kind, reason } = detectRepoKind(manifests2, sources);
+  if (kind === "library") notes.push(`Library/SDK layout detected (${reason}): call sites are most likely pass-through wrappers where the caller chooses the model and prompt, so findings are downgraded one level and the estimate is discounted.`);
+  const promptLibrary = [];
+  const repoCaches = sources.some((f) => /cache_control|cacheControl|prompt_cache_key|promptCacheKey|cachedContent|cached_content/.test(f.content));
+  const PROMPT_FILE = /(^|\/)[^/]*(prompt|instruction|template|persona)s?[^/]*\.[a-z]+$|(^|\/)prompts?\//i;
+  const PROMPT_NAME = /\b[\w.]*(prompt|system|instruction|template|persona)\w*\s*(:\s*[\w[\]|. ]+)?\s*[:=]\s*(f|r|rf|fr|b)?$/i;
+  for (const f of sources) {
+    const src = f.content, lines = src.split("\n");
+    const { masked, literals } = lex(src, f.path);
+    for (const l of literals) {
+      if (!promptLike(l.text)) continue;
+      const tokens = countTokens(l.text);
+      if (tokens < 300) continue;
+      const lead = (masked[l.line - 1] ?? "").slice(0, Math.max(0, (masked[l.line - 1] ?? "").search(/["'`]|$/))).trimEnd();
+      if (PROMPT_FILE.test(f.path) || PROMPT_NAME.test(lead) || PROMPT_NAME.test((masked[l.line - 2] ?? "").trimEnd())) promptLibrary.push({ file: f.path, line: l.line, tokens });
+    }
+    const hasCacheControl = /cache_control|cacheControl|prompt_cache_key|promptCacheKey|cachedContent|cached_content/.test(src);
+    const illustrative = EXAMPLE_PATH.test(f.path);
+    let repeatFlagged = false;
+    masked.forEach((code, i) => {
+      const sdk = CALL_RE.find(([re]) => re.test(code))?.[1];
+      if (!sdk) return;
+      const local = [];
+      const push = (fd) => {
+        let sev = fd.severity;
+        if (kind === "library") sev = DOWN[sev];
+        if (illustrative) sev = DOWN[sev];
+        local.push({ ...fd, severity: sev });
+      };
+      const window = lines.slice(i, Math.min(lines.length, i + 30)).join("\n");
+      const model = [...window.matchAll(MODEL_RE)].map((m) => m[1])[0] ?? null;
+      callSites.push({ file: f.path, line: i + 1, model, sdk });
+      if (model) models[model] = (models[model] ?? 0) + 1;
+      const key = normalizeModel(model);
+      const price = key ? priceFor(key) : null;
+      const near = literals.filter((l) => l.line >= i + 1 - 40 && l.line <= i + 1 + 40);
+      const prompts = near.filter((l) => promptLike(l.text));
+      const codeCtx = masked.slice(Math.max(0, i - 25), i + 25).join("\n");
+      const simpleTask = near.some((l) => SIMPLE_TASK.test(l.text));
+      const isAnthropic = sdk.includes("anthropic") || (model?.startsWith("claude") ?? false);
+      const bigTok = prompts.reduce((a, l) => a + countTokens(l.text), 0);
+      if (bigTok >= 300 && !hasCacheControl) {
+        const readRate = price?.cachedInput != null && price.input ? Math.round((1 - price.cachedInput / price.input) * 100) : 90;
+        const min = price?.minCacheTokens ?? 1024;
+        const cacheable = bigTok >= min || isAnthropic && bigTok >= 512;
+        push({
+          severity: isAnthropic ? bigTok >= 1500 ? "high" : cacheable ? "medium" : "low" : cacheable ? "medium" : "low",
+          file: f.path,
+          line: prompts[0].line,
+          title: `~${bigTok.toLocaleString()} static prompt tokens re-billed at full price on every call`,
+          detail: isAnthropic ? `This call sends a large fixed prompt but never marks a cache breakpoint, so Anthropic bills all ${bigTok} tokens at the full input rate each time instead of the cache-read rate (${readRate}% cheaper).` : `A fixed prefix of ~${bigTok} tokens is sent on every call. Prefix caching applies only to stable prefixes of at least ${min} tokens on this model; keep the static part first and nothing volatile (timestamps, ids) interpolated into it.`,
+          fix: isAnthropic ? 'Route through TokenZero (breakpoints are injected automatically) or add `cache_control: {type: "ephemeral"}` to the last system block and the last tool.' : "Route through TokenZero to get a stable `prompt_cache_key`, or move dynamic content below the static prefix and set `prompt_cache_key` yourself.",
+          // OpenAI/Gemini already cache stable prefixes automatically; the recoverable part
+          // is prefix hygiene and cache routing, not the whole cache discount.
+          est_savings_pct: !cacheable ? 0 : isAnthropic ? Math.min(85, Math.round(bigTok / (bigTok + 400) * readRate)) : 15
+        });
+      }
+      if (key && price?.tier === "frontier" && CASCADE_TARGET[key] && simpleTask) {
+        const to = CASCADE_TARGET[key];
+        const a = costOf(key, { input: 1500, output: 200 }), b = costOf(to, { input: 1500, output: 200 });
+        push({
+          severity: "high",
+          file: f.path,
+          line: i + 1,
+          title: `${key} used for a task whose prompt reads like extraction/classification`,
+          detail: `Frontier pricing ($${price.input}/M in, $${price.output}/M out) on a constrained task. ${to} costs ~${Math.round((1 - b / a) * 100)}% less per call at this shape.`,
+          fix: `Opt into TokenZero cascade routing (\`X-TokenZero-Cascade: auto\`) so this call is routed to ${to} only when the classifier is confident, with parity reported in the ledger, or switch the model here behind an eval.`,
+          est_savings_pct: Math.round((1 - b / a) * 100)
+        });
+      }
+      const above = masked.slice(Math.max(0, i - 6), i).join("\n");
+      if (/^\s*(for|while)\b|\.map\(|\.forEach\(|asyncio\.gather|Promise\.all/m.test(above) && !/batch/i.test(codeCtx)) {
+        push({
+          severity: "medium",
+          file: f.path,
+          line: i + 1,
+          title: "LLM call inside a loop",
+          detail: "Per-item calls repeat the full prompt prefix for every element. If items are independent and latency-tolerant, the provider Batch API is 50% cheaper; if the prefix is shared, caching pays off immediately.",
+          fix: "Batch where possible; otherwise keep the shared prefix cache-formatted (TokenZero does this automatically).",
+          est_savings_pct: 25
+        });
+      }
+      if (simpleTask && !repeatFlagged && !/seed\s*[:=]|temperature\s*[:=]\s*0\b/.test(codeCtx)) {
+        repeatFlagged = true;
+        push({
+          severity: "info",
+          file: f.path,
+          line: i + 1,
+          title: "Repeat-prone task with no response-cache opt-in",
+          detail: "Classification and extraction calls often see identical inputs. Without a determinism signal no proxy can safely serve repeats from cache.",
+          fix: "If identical inputs should get identical answers, send `X-TokenZero-Cache: always` on these calls (or `temperature: 0` / a `seed` on models that still accept them). Repeats are then served in <10 ms at $0.",
+          est_savings_pct: 10
+        });
+      }
+      if (isAnthropic && /\btools\s*[:=]/.test(masked.slice(i, i + 30).join("\n")) && !hasCacheControl) {
+        push({
+          severity: "low",
+          file: f.path,
+          line: i + 1,
+          title: "Tool definitions sent without a cache breakpoint",
+          detail: "Tool schemas render before the system prompt in the cached prefix. Without a breakpoint on the last tool they are billed in full on every call.",
+          fix: "TokenZero marks the last tool automatically; manually, add `cache_control` to the last tool definition.",
+          est_savings_pct: 8
+        });
+      }
+      if (model && !key && !unknownModels.has(model)) {
+        unknownModels.add(model);
+        push({ severity: "info", file: f.path, line: i + 1, title: `Unrecognised model id "${model}"`, detail: "Not in the current pricing table: it may be retired or renamed. Retired models return errors or are silently remapped by some providers.", fix: "Check the provider model list; TokenZero flags unpriced models in `X-TokenZero-Warning`.", est_savings_pct: 0 });
+      }
+      findings.push(...local);
+      siteFindings.push(local);
+    });
+  }
+  const libTokens = promptLibrary.reduce((a, p) => a + p.tokens, 0);
+  if (callSites.length && !repoCaches && libTokens >= 1024 && !findings.some((f) => /static prompt tokens/.test(f.title))) {
+    const anth = callSites.filter((c2) => c2.sdk.includes("anthropic") || c2.model?.startsWith("claude")).length;
+    const anthropicHeavy = anth * 2 >= callSites.length;
+    const top = promptLibrary.slice().sort((a, b) => b.tokens - a.tokens)[0];
+    const sev = anthropicHeavy ? libTokens >= 3e3 ? "high" : "medium" : "medium";
+    const fd = {
+      severity: kind === "library" ? DOWN[sev] : sev,
+      file: top.file,
+      line: top.line,
+      title: `${promptLibrary.length} static prompt template(s), ~${libTokens.toLocaleString()} tokens, and no caching directive anywhere in the repo`,
+      detail: anthropicHeavy ? "Most call sites use Anthropic, which only discounts cached input when the request marks a cache breakpoint. None of these prompts can be served from cache as written, so every call pays the full input rate for them." : "Most call sites use providers with automatic prefix caching, which only pays off when these templates are sent as a byte-identical prefix: static template first, nothing volatile (dates, ids, user data) interpolated into it.",
+      fix: anthropicHeavy ? 'Route through TokenZero (breakpoints are injected on tools and system automatically) or add `cache_control: {type: "ephemeral"}` after each static template.' : "Keep templates first and static; TokenZero adds a stable `prompt_cache_key` so related requests land on the same cache.",
+      est_savings_pct: anthropicHeavy ? Math.min(70, Math.round(libTokens / (libTokens + 2e3) * 85)) : 12
+    };
+    findings.push(fd);
+    for (const site of siteFindings) site.push(fd);
+  }
+  const weight = { high: 1, medium: 0.6, low: 0.3, info: 0 };
+  const perSite = siteFindings.map((fs3) => 1 - fs3.reduce((rem, f) => rem * (1 - f.est_savings_pct / 100 * weight[f.severity]), 1));
+  let waste = perSite.length ? perSite.reduce((a, b) => a + b, 0) / perSite.length : 0;
+  if (kind === "library") waste *= 0.3;
+  const wastePct = Math.round(Math.min(0.7, waste) * 100);
+  if (!callSites.length) notes.push("No recognised LLM call sites (OpenAI, Anthropic, Gemini, Vercel AI SDK, LangChain, LiteLLM). Calls behind custom wrappers are not detected.");
+  const topModel = Object.entries(models).sort((a, b) => b[1] - a[1]).map(([m]) => normalizeModel(m)).find(Boolean) ?? null;
+  let cost = null;
+  if (topModel && PRICES[topModel]) {
+    const assumed = 2e3;
+    const before = costOf(topModel, { input: assumed, output: 300 }) * 1e4;
+    cost = { model: topModel, assumed_prompt_tokens: assumed, before_usd: Math.round(before * 100) / 100, after_usd: Math.round(before * (1 - wastePct / 100) * 100) / 100 };
+  }
+  const order = { high: 0, medium: 1, low: 2, info: 3 };
+  findings.sort((a, b) => order[a.severity] - order[b.severity] || b.est_savings_pct - a.est_savings_pct);
+  const id = "aud_" + crypto.randomBytes(16).toString("base64url");
+  return { id, repo, method: "static heuristics", repo_kind: kind, notes, scanned_files: sources.length, call_sites: callSites, models, findings, estimated_waste_pct: wastePct, cost_per_10k_runs: cost, badge_url: null, generated_at: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function filesFromDiff(diff) {
+  const files = [];
+  let cur = null;
+  for (const line of diff.split("\n")) {
+    const m = /^\+\+\+ b\/(.+)$/.exec(line);
+    if (m) {
+      cur = { path: m[1], content: "" };
+      files.push(cur);
+      continue;
+    }
+    if (!cur) continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) cur.content += line.slice(1) + "\n";
+    else if (line.startsWith(" ")) cur.content += line.slice(1) + "\n";
+    else if (line.startsWith("@@")) cur.content += "\n";
+  }
+  return files;
+}
+function prComment(report, publicUrl) {
+  const c2 = report.cost_per_10k_runs;
+  const head = c2 ? `**TokenZero FinOps check** \u2014 estimated cost per 10k runs: \`$${c2.before_usd}\` \u2192 \`$${c2.after_usd}\` (${report.estimated_waste_pct}% recoverable) on \`${c2.model}\`` : `**TokenZero FinOps check** \u2014 ${report.findings.length} finding(s), ${report.call_sites.length} LLM call site(s)`;
+  const rows = report.findings.slice(0, 8).map((f) => `| ${f.severity} | \`${f.file}:${f.line}\` | ${f.title} | ${f.est_savings_pct}% |`).join("\n");
+  return [
+    head,
+    "",
+    report.findings.length ? "| severity | where | finding | est. savings |\n|---|---|---|---|\n" + rows : "_No token-waste patterns found in the changed lines._",
+    "",
+    report.findings.slice(0, 3).map((f) => `<details><summary>${f.title}</summary>
+
+${f.detail}
+
+**Fix:** ${f.fix}
+</details>`).join("\n"),
+    "",
+    `One-line fix for everything above: point your SDK at \`${publicUrl}/v1\` (BYOK; your keys pass straight through). [How it works](${publicUrl}) \xB7 [Full report](${publicUrl}/audit/${report.id})`,
+    ...report.notes.map((n) => `> ${n}`),
+    "",
+    "<sub>Estimates are static heuristics at list prices, not measurements. Verified numbers come from the signed ledger once traffic flows.</sub>"
+  ].join("\n");
+}
+
+// cli/src/scan.ts
+import fs from "node:fs";
+import path from "node:path";
+function walk(root, limit = 5e3) {
+  const files = [];
+  const stack = [root];
+  while (stack.length && files.length < limit) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      const rel = path.relative(root, full).split(path.sep).join("/");
+      if (e.name.startsWith(".") && e.name !== ".github") continue;
+      if (SKIP_PATH.test(rel + (e.isDirectory() ? "/" : ""))) continue;
+      if (e.isDirectory()) stack.push(full);
+      else if (e.isFile() && SOURCE_EXT.test(e.name)) {
+        try {
+          const st = fs.statSync(full);
+          if (st.size < 4e5) files.push({ path: rel, content: fs.readFileSync(full, "utf8") });
+        } catch {
+        }
+      }
+    }
+  }
+  return files;
+}
+function manifests(root) {
+  return MANIFEST_FILES.flatMap((n) => {
+    try {
+      return [{ path: n, content: fs.readFileSync(path.join(root, n), "utf8") }];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// src/canonical.ts
+function canonical(obj) {
+  if (obj === null || typeof obj !== "object") return JSON.stringify(obj);
+  if (Array.isArray(obj)) return "[" + obj.map(canonical).join(",") + "]";
+  const o = obj;
+  return "{" + Object.keys(o).sort().filter((k) => o[k] !== void 0).map((k) => JSON.stringify(k) + ":" + canonical(o[k])).join(",") + "}";
+}
+
+// cli/src/main.ts
+var VERSION = "0.1.0";
+var BAKED_URL = typeof __TOKENZERO_BAKED__ === "string" ? __TOKENZERO_BAKED__ : "__TOKENZERO_DEFAULT_URL__";
+function parseArgs(argv) {
+  const a = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (t === "--") {
+      a._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (t.startsWith("--")) {
+      const [k, v] = t.slice(2).split("=", 2);
+      if (v !== void 0) a.flags[k] = v;
+      else if (argv[i + 1] && !argv[i + 1].startsWith("-") && VALUE_FLAGS.has(k)) a.flags[k] = argv[++i];
+      else a.flags[k] = true;
+    } else if (t === "-y") a.flags.yes = true;
+    else a._.push(t);
+  }
+  return a;
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["url", "name", "key", "format", "diff", "fail-over", "env-file"]);
+var tty = process.stdout.isTTY && !process.env.NO_COLOR;
+var c = (code) => (s) => tty ? `\x1B[${code}m${s}\x1B[0m` : s;
+var bold = c("1");
+var dim = c("2");
+var green = c("32");
+var yellow = c("33");
+var red = c("31");
+var cyan = c("36");
+var out = (s = "") => process.stdout.write(s + "\n");
+var err = (s) => process.stderr.write(s + "\n");
+function baseUrl(a) {
+  const u = a.flags.url || process.env.TOKENZERO_URL || (BAKED_URL.startsWith("http") ? BAKED_URL : "");
+  return u ? u.replace(/\/+$/, "") : null;
+}
+async function confirm(q, a) {
+  if (a.flags.yes) return true;
+  if (!process.stdin.isTTY) return false;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ans = (await rl.question(`${q} ${dim("[y/N]")} `)).trim().toLowerCase();
+  rl.close();
+  return ans === "y" || ans === "yes";
+}
+async function api(base, p, init = {}) {
+  let r;
+  try {
+    r = await fetch(base + p, { ...init, redirect: "manual", headers: { "content-type": "application/json", "user-agent": `tokenzero-cli/${VERSION}`, ...init.headers ?? {} } });
+  } catch (e) {
+    throw new Error(`cannot reach ${base}: ${e?.cause?.code ?? e?.message ?? e}`);
+  }
+  if (r.status >= 300 && r.status < 400) throw new Error(`${base} redirected (${r.status}) instead of answering; the gateway is not publicly reachable yet`);
+  const text = await r.text();
+  let body = text;
+  try {
+    body = JSON.parse(text);
+  } catch {
+  }
+  return { status: r.status, body };
+}
+function detectStack(root) {
+  const sdks = /* @__PURE__ */ new Set();
+  let lang = "unknown";
+  const read = (f) => {
+    try {
+      return fs2.readFileSync(path2.join(root, f), "utf8");
+    } catch {
+      return "";
+    }
+  };
+  const pkg = read("package.json");
+  if (pkg) {
+    lang = "node";
+    try {
+      const j = JSON.parse(pkg);
+      const deps = { ...j.dependencies, ...j.devDependencies };
+      if (deps.openai) sdks.add("openai");
+      if (deps["@anthropic-ai/sdk"]) sdks.add("anthropic");
+      if (deps.ai || Object.keys(deps).some((d) => d.startsWith("@ai-sdk/"))) sdks.add("vercel-ai");
+      if (Object.keys(deps).some((d) => d.startsWith("@langchain/") || d === "langchain")) sdks.add("langchain");
+      if (deps["@google/genai"]) sdks.add("gemini");
+    } catch {
+    }
+  }
+  const py = read("requirements.txt") + read("pyproject.toml") + read("Pipfile") + read("setup.py");
+  if (py) {
+    if (lang === "unknown") lang = "python";
+    if (/^\s*["']?openai\b/im.test(py)) sdks.add("openai");
+    if (/^\s*["']?anthropic\b/im.test(py)) sdks.add("anthropic");
+    if (/langchain/i.test(py)) sdks.add("langchain");
+    if (/litellm/i.test(py)) sdks.add("litellm");
+    if (/google-genai|google-generativeai/i.test(py)) sdks.add("gemini");
+  }
+  return { lang, sdks: [...sdks] };
+}
+var ENV_KEYS = ["OPENAI_BASE_URL", "ANTHROPIC_BASE_URL", "TOKENZERO_URL", "TOKENZERO_KEY"];
+function planEnv(file, wanted) {
+  const existing = fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : "";
+  const current = {};
+  for (const line of existing.split("\n")) {
+    const m = /^\s*(?:export\s+)?([A-Z0-9_]+)\s*=\s*(.*)$/.exec(line);
+    if (m) current[m[1]] = m[2].replace(/^["']|["']$/g, "");
+  }
+  const add = [], conflicts = [];
+  for (const [k, v] of Object.entries(wanted)) {
+    if (!(k in current)) add.push(`${k}=${v}`);
+    else if (current[k] !== v) conflicts.push(k);
+  }
+  return { existing, add, conflicts, exists: !!existing };
+}
+function gitignored(root, name) {
+  try {
+    return fs2.readFileSync(path2.join(root, ".gitignore"), "utf8").split("\n").some((l) => {
+      const t = l.trim();
+      return t === name || t === "/" + name || t === name + "*" || t === ".env*" || t === "*.env";
+    });
+  } catch {
+    return false;
+  }
+}
+function summarize(r, limit = 5) {
+  out(`${bold("Audit")} ${dim("(static heuristics, local only: no source left this machine)")}`);
+  out(`  ${r.scanned_files} files \xB7 ${r.call_sites.length} LLM call site(s) \xB7 ${r.findings.length} finding(s) \xB7 repo looks like: ${r.repo_kind}`);
+  for (const n of r.notes) out(dim(`  note: ${n}`));
+  if (r.cost_per_10k_runs) out(`  est. cost per 10k runs on ${r.cost_per_10k_runs.model}: $${r.cost_per_10k_runs.before_usd} \u2192 ${green("$" + r.cost_per_10k_runs.after_usd)} (~${r.estimated_waste_pct}% recoverable)`);
+  for (const f of r.findings.slice(0, limit)) {
+    const sev = f.severity === "high" ? red(f.severity) : f.severity === "medium" ? yellow(f.severity) : dim(f.severity);
+    out(`  ${sev.padEnd(tty ? 15 : 6)} ${cyan(f.file + ":" + f.line)}  ${f.title}`);
+  }
+  if (r.findings.length > limit) out(dim(`  \u2026 ${r.findings.length - limit} more (run the audit command for the full list)`));
+}
+function snippet(sdk, lang) {
+  const py = lang === "python";
+  switch (sdk) {
+    case "openai":
+      return py ? "OpenAI()            # reads OPENAI_BASE_URL; no code change" : "new OpenAI()        // reads OPENAI_BASE_URL; no code change";
+    case "anthropic":
+      return py ? "Anthropic()         # reads ANTHROPIC_BASE_URL; no code change" : "new Anthropic()     // reads ANTHROPIC_BASE_URL; no code change";
+    case "vercel-ai":
+      return 'createOpenAI({ baseURL: process.env.OPENAI_BASE_URL }) / createAnthropic({ baseURL: process.env.ANTHROPIC_BASE_URL + "/v1" })';
+    case "langchain":
+      return py ? 'ChatOpenAI(base_url=os.environ["OPENAI_BASE_URL"]) / ChatAnthropic(base_url=os.environ["ANTHROPIC_BASE_URL"])' : "new ChatOpenAI({ configuration: { baseURL: process.env.OPENAI_BASE_URL } })";
+    case "litellm":
+      return "litellm reads OPENAI_BASE_URL / ANTHROPIC_BASE_URL (api_base) per provider";
+    case "gemini":
+      return "use the OpenAI SDK against OPENAI_BASE_URL with your Gemini key (AIza\u2026)";
+    default:
+      return null;
+  }
+}
+async function cmdInit(a) {
+  const root = path2.resolve(a._[1] ?? ".");
+  const base = baseUrl(a);
+  out(`${bold("TokenZero")} init ${dim("v" + VERSION)} in ${root}
+`);
+  const stack = detectStack(root);
+  out(`${bold("Project")}  ${stack.lang}${stack.sdks.length ? " \xB7 " + stack.sdks.join(", ") : dim(" \xB7 no LLM SDK found in manifests")}`);
+  const report = analyzeFiles(walk(root), null, manifests(root));
+  out();
+  summarize(report, 5);
+  out();
+  if (!base) {
+    err(red("No gateway URL. Pass --url https://\u2026 or set TOKENZERO_URL."));
+    process.exitCode = 2;
+    return;
+  }
+  let key = a.flags.key || process.env.TOKENZERO_KEY || "";
+  let wsId = "";
+  if (!key) {
+    try {
+      const r = await api(base, "/v1/workspaces", { method: "POST", body: JSON.stringify({ name: a.flags.name ?? path2.basename(root) }) });
+      if (r.status !== 201) throw new Error(`workspace creation failed (${r.status}): ${JSON.stringify(r.body).slice(0, 200)}`);
+      key = r.body.key;
+      wsId = r.body.workspace.id;
+      out(`${bold("Workspace")} ${wsId} ${dim("created")}`);
+    } catch (e) {
+      err(yellow(`! ${e.message}`));
+      err(dim("  Continuing without a workspace key: requests will be grouped by an anonymous workspace derived from your provider key."));
+    }
+  }
+  const prefix = key ? `${base}/w/${key}` : base;
+  const wanted = { OPENAI_BASE_URL: `${prefix}/v1`, ANTHROPIC_BASE_URL: prefix, TOKENZERO_URL: base };
+  if (key) wanted.TOKENZERO_KEY = key;
+  const envFile = path2.join(root, a.flags["env-file"] ?? ".env");
+  const plan = planEnv(envFile, wanted);
+  out(`
+${bold("Environment")} ${dim("(your provider keys stay where they are; they pass through untouched)")}`);
+  for (const k of ENV_KEYS) if (wanted[k]) out(`  ${k}=${k === "TOKENZERO_KEY" || k.endsWith("BASE_URL") && key ? redactKey(wanted[k], key) : wanted[k]}`);
+  if (plan.conflicts.length) out(yellow(`  ! ${path2.basename(envFile)} already sets ${plan.conflicts.join(", ")} to other values; left unchanged`));
+  if (a.flags["no-env"]) out(dim(`  --no-env: add the lines above to your environment yourself.`));
+  else if (plan.add.length && await confirm(`
+Append ${plan.add.length} line(s) to ${path2.relative(root, envFile) || ".env"}?`, a)) {
+    const sep = plan.existing && !plan.existing.endsWith("\n") ? "\n" : "";
+    fs2.appendFileSync(envFile, `${sep}
+# TokenZero (BYOK gateway): ${base}
+${plan.add.join("\n")}
+`, { mode: 384 });
+    out(green(`  \u2713 wrote ${path2.relative(root, envFile) || ".env"}`));
+    if (fs2.existsSync(path2.join(root, ".git")) && !gitignored(root, path2.basename(envFile))) out(yellow(`  ! ${path2.basename(envFile)} is not in .gitignore; it now holds your TokenZero key`));
+  } else if (plan.add.length) out(dim("  not written; run with --yes to write, or copy the lines above."));
+  if (stack.sdks.length) {
+    out(`
+${bold("Your code")}`);
+    for (const s of stack.sdks) {
+      const sn = snippet(s, stack.lang);
+      if (sn) out(`  ${s.padEnd(10)} ${sn}`);
+    }
+  }
+  if (a.flags.mcp) await setupMcp(root, base, a);
+  out(`
+${bold("Next")}`);
+  if (wsId) out(`  dashboard   ${base}/dashboard?workspace=${wsId}`);
+  out(`  usage       ${selfCmd(base)} usage`);
+  if (wsId) out(`  badge       turn on public stats in the dashboard, then: [![LLM spend verified by TokenZero](${base}/v1/badge/${wsId}.svg)](${base}/dashboard?workspace=${wsId})`);
+  if (!a.flags.mcp) out(`  coding agents: ${selfCmd(base)} init --mcp`);
+}
+var selfCmd = (base) => `npx -y ${base}/cli/tokenzero.tgz`;
+var redactKey = (s, key) => key ? s.replace(key, key.slice(0, 12) + "\u2026" + key.slice(-4)) : s;
+async function setupMcp(root, base, a) {
+  out(`
+${bold("MCP")} ${dim("(audit_repo_token_waste, optimize_prompt_payload, calculate_model_arbitrage)")}`);
+  out(`  Claude Code:  claude mcp add --transport http tokenzero ${base}/mcp`);
+  const cursorDir = path2.join(root, ".cursor");
+  const file = path2.join(cursorDir, "mcp.json");
+  let cfg = {};
+  if (fs2.existsSync(file)) {
+    try {
+      cfg = JSON.parse(fs2.readFileSync(file, "utf8"));
+    } catch {
+      out(yellow(`  ! ${file} is not valid JSON; not touching it`));
+      return;
+    }
+  }
+  if (cfg?.mcpServers?.tokenzero?.url === `${base}/mcp`) {
+    out(dim("  Cursor: already configured"));
+    return;
+  }
+  if (await confirm(`  Add TokenZero to ${path2.relative(root, file)} for Cursor?`, a)) {
+    cfg.mcpServers = { ...cfg.mcpServers ?? {}, tokenzero: { url: `${base}/mcp` } };
+    fs2.mkdirSync(cursorDir, { recursive: true });
+    fs2.writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n");
+    out(green(`  \u2713 wrote ${path2.relative(root, file)}`));
+  }
+}
+async function cmdAudit(a) {
+  const root = path2.resolve(a._[1] ?? ".");
+  let report;
+  if (a.flags.diff) {
+    const src = a.flags.diff === "-" || a.flags.diff === true ? fs2.readFileSync(0, "utf8") : fs2.readFileSync(a.flags.diff, "utf8");
+    report = analyzeFiles(filesFromDiff(src), null);
+  } else report = analyzeFiles(walk(root), null, manifests(root));
+  const fmt = a.flags.format ?? (a.flags.json ? "json" : "text");
+  if (fmt === "json") out(JSON.stringify(report, null, 2));
+  else if (fmt === "markdown") out(prComment(report, baseUrl(a) ?? "https://tokenzero.sh"));
+  else {
+    summarize(report, 100);
+    for (const f of report.findings.slice(0, 3)) out(`
+${bold(f.title)}
+  ${f.detail}
+  ${green("fix:")} ${f.fix}`);
+  }
+  const gate = Number(a.flags["fail-over"]);
+  if (Number.isFinite(gate) && a.flags["fail-over"] !== void 0 && report.estimated_waste_pct > gate) {
+    err(red(`recoverable waste ${report.estimated_waste_pct}% exceeds --fail-over ${gate}%`));
+    process.exitCode = 1;
+  }
+}
+async function cmdUsage(a) {
+  const base = baseUrl(a);
+  const key = a.flags.key || process.env.TOKENZERO_KEY;
+  if (!base || !key) {
+    err(red("Need TOKENZERO_URL and TOKENZERO_KEY (run tokenzero init), or --url and --key."));
+    process.exitCode = 2;
+    return;
+  }
+  const [u, s] = await Promise.all([api(base, "/v1/usage", { headers: { "x-tokenzero-key": key } }), api(base, "/v1/ledger/stats", { headers: { "x-tokenzero-key": key } })]);
+  if (u.status !== 200) {
+    err(red(`usage: ${u.status} ${JSON.stringify(u.body).slice(0, 200)}`));
+    process.exitCode = 1;
+    return;
+  }
+  if (a.flags.json) {
+    out(JSON.stringify({ usage: u.body, stats: s.body }, null, 2));
+    return;
+  }
+  const d = u.body;
+  const barW = 30, filled = Math.round(d.free_tier_used_pct / 100 * barW);
+  out(`${bold(d.workspace)} \xB7 ${d.month} \xB7 plan ${d.plan}`);
+  out(`  routed spend  $${d.routed_usd.toFixed(2)} of $${d.free_tier_limit_usd} free  [${(d.free_tier_used_pct >= 80 ? yellow : green)("\u2588".repeat(filled))}${dim("\u2591".repeat(barW - filled))}] ${d.free_tier_used_pct}%`);
+  out(`  actual spend  $${d.actual_usd.toFixed(2)}   saved ${green("$" + d.savings_usd.toFixed(2))}   requests ${d.requests}`);
+  if (s.status === 200 && s.body.savings_pct != null) out(`  last 30 days  ${s.body.savings_pct}% saved \xB7 ${s.body.cache_hits} cache hits \xB7 projected $${s.body.projected_monthly_savings_usd.toFixed(2)}/mo`);
+  if (d.engines_paused) out(yellow(`  engines paused: free tier reached; traffic passes through unoptimised until ${d.resets_at}`));
+  out(dim(`  fee preview: $${d.fee_preview.estimated_fee_usd.toFixed(2)} (${d.fee_preview.label})`));
+}
+async function cmdRotate(a) {
+  const base = baseUrl(a);
+  const key = a.flags.key || process.env.TOKENZERO_KEY;
+  if (!base || !key) {
+    err(red("Need TOKENZERO_URL and TOKENZERO_KEY (or --url and --key)."));
+    process.exitCode = 2;
+    return;
+  }
+  const root = path2.resolve(a._[1] ?? ".");
+  const envFile = path2.join(root, a.flags["env-file"] ?? ".env");
+  if (!await confirm(`Rotate the workspace key? The current key stops working immediately.`, a)) {
+    out(dim("cancelled"));
+    return;
+  }
+  const r = await api(base, "/v1/workspaces/me/rotate-key", { method: "POST", headers: { "x-tokenzero-key": key } });
+  if (r.status !== 200) {
+    err(red(`rotate: ${r.status} ${JSON.stringify(r.body).slice(0, 200)}`));
+    process.exitCode = 1;
+    return;
+  }
+  const fresh = r.body.key;
+  out(green(`\u2713 rotated; old key ${redactKey(key, key)} is now invalid`));
+  if (fs2.existsSync(envFile)) {
+    const before = fs2.readFileSync(envFile, "utf8");
+    const after = before.split(key).join(fresh);
+    if (after !== before) {
+      fs2.writeFileSync(envFile, after, { mode: 384 });
+      out(green(`\u2713 updated ${path2.relative(root, envFile) || ".env"} (TOKENZERO_KEY and /w/<key>/ base URLs)`));
+      return;
+    }
+  }
+  out(`New key (shown once): ${fresh}`);
+  out(dim("Update TOKENZERO_KEY and any /w/<key>/ base URLs wherever the old key was configured (CI secrets, hosting env)."));
+}
+async function cmdVerify(a) {
+  const base = baseUrl(a);
+  const id = a._[1];
+  if (!base || !id) {
+    err(red("usage: tokenzero verify <request_id> [--url \u2026]"));
+    process.exitCode = 2;
+    return;
+  }
+  const [r, k] = await Promise.all([api(base, `/v1/ledger/receipt/${encodeURIComponent(id)}`), api(base, "/.well-known/tokenzero.json")]);
+  if (r.status !== 200) {
+    err(red(`receipt: ${r.status}`));
+    process.exitCode = 1;
+    return;
+  }
+  const jwk = (k.body?.keys ?? []).find((x) => x.kid === r.body.receipt.key_id);
+  if (!jwk) {
+    err(red(`no public key with kid ${r.body.receipt.key_id} at ${base}/.well-known/tokenzero.json`));
+    process.exitCode = 1;
+    return;
+  }
+  const pub = crypto2.createPublicKey({ key: { kty: jwk.kty, crv: jwk.crv, x: jwk.x }, format: "jwk" });
+  const ok = crypto2.verify(null, Buffer.from(canonical(r.body.receipt)), pub, Buffer.from(r.body.signature, "base64url"));
+  const rc = r.body.receipt;
+  out(`${ok ? green("\u2713 valid") : red("\u2717 INVALID")} signature (Ed25519, key ${rc.key_id}, verified locally)`);
+  out(`  ${rc.id} \xB7 ${new Date(rc.ts).toISOString()} \xB7 ${rc.provider} ${rc.requested_model}${rc.served_model && rc.served_model !== rc.requested_model ? " \u2192 " + rc.served_model : ""}`);
+  out(`  baseline $${rc.baseline_usd} \xB7 actual $${rc.actual_usd} \xB7 saved $${rc.savings_usd} \xB7 engines ${rc.engines.join(",") || "none"} \xB7 pricing ${rc.pricing_version}`);
+  if (!ok) process.exitCode = 1;
+}
+function help() {
+  out(`${bold("tokenzero")} v${VERSION} \u2014 cut your LLM bill with a BYOK gateway
+
+  ${bold("tokenzero init")} [dir] [--url URL] [--name NAME] [--yes] [--no-env] [--mcp]
+      Audit locally, create a workspace, point OPENAI_BASE_URL / ANTHROPIC_BASE_URL at the gateway.
+  ${bold("tokenzero audit")} [dir] [--json | --format markdown] [--diff file|-] [--fail-over PCT]
+      Static token-waste audit. Runs locally; nothing is uploaded. --fail-over makes it a CI gate.
+  ${bold("tokenzero usage")} [--json]          Routed spend vs the free tier, savings, fee preview.
+  ${bold("tokenzero verify")} <request_id>     Verify a savings receipt's signature offline.
+  ${bold("tokenzero rotate-key")} [--yes]      Issue a new workspace key; rewrites it in .env. Old key dies immediately.
+
+  Env: TOKENZERO_URL, TOKENZERO_KEY, NO_COLOR`);
+}
+async function main() {
+  process.stdout.on("error", (e) => {
+    if (e.code === "EPIPE") process.exit(0);
+    throw e;
+  });
+  const a = parseArgs(process.argv.slice(2));
+  const cmd = a._[0];
+  if (a.flags.version || cmd === "version") return out(VERSION);
+  switch (cmd) {
+    case "init":
+      return cmdInit(a);
+    case "audit":
+      return cmdAudit(a);
+    case "usage":
+      return cmdUsage(a);
+    case "verify":
+      return cmdVerify(a);
+    case "rotate-key":
+      return cmdRotate(a);
+    case void 0:
+    case "help":
+      return help();
+    default:
+      err(red(`unknown command: ${cmd}`));
+      help();
+      process.exitCode = 2;
+  }
+}
+main().catch((e) => {
+  err(red(`error: ${e?.message ?? e}`));
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "@tokenzero/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "TokenZero CLI: connect a project to the TokenZero BYOK gateway, audit LLM token waste locally, check usage and verify signed savings receipts.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "TokenZero Contributors <support@tokenzero.sh>",
+  "homepage": "https://tokenzero.sh",
+  "bin": { "tokenzero": "bin/tokenzero.mjs" },
+  "files": ["bin/tokenzero.mjs"],
+  "engines": { "node": ">=18" },
+  "keywords": ["llm", "openai", "anthropic", "gemini", "cost", "finops", "prompt-caching", "mcp"]
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.