token-goat 2.9.19 → 2.9.21

package/dist/token-goat-chunk-KQI24O4B.mjs

@@ -0,0 +1,292 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  accumulateResidentLine,
+  claudeConfigDir,
+  createResidentContextStats,
+  estimateTokens,
+  summarizeResidentContext
+} from "./token-goat-chunk-MEKVJZUN.mjs";
+import {
+  commandHash,
+  getBashOutput,
+  normalizeCommandForCacheKey
+} from "./token-goat-chunk-M43UJVYQ.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/waste.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+function projectTranscriptsDir(projectRoot) {
+  const rootStr = path.resolve(projectRoot);
+  const slug = rootStr.replace(/[^A-Za-z0-9]/g, "-");
+  return path.join(claudeConfigDir(), "projects", slug);
+}
+function findLatestTranscript(projectRoot) {
+  const dir = projectTranscriptsDir(projectRoot);
+  let entries;
+  try {
+    entries = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of entries) {
+    const full = path.join(dir, name);
+    let stat;
+    try {
+      stat = fs.statSync(full);
+    } catch {
+      continue;
+    }
+    if (best === null || stat.mtimeMs > best.mtimeMs) best = { file: full, mtimeMs: stat.mtimeMs };
+  }
+  return best?.file ?? null;
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+var FILE_PATH_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "NotebookEdit", "MultiEdit"]);
+function extractFilePath(name, input) {
+  if (!FILE_PATH_TOOLS.has(name)) return null;
+  if (input === null || typeof input !== "object") return null;
+  const o = input;
+  const fp = o["file_path"];
+  if (typeof fp === "string") return fp;
+  const notebookPath = o["notebook_path"];
+  return typeof notebookPath === "string" ? notebookPath : null;
+}
+function extractCommand(name, input) {
+  if (name !== "Bash") return null;
+  if (input === null || typeof input !== "object") return null;
+  const cmd = input["command"];
+  return typeof cmd === "string" ? cmd : null;
+}
+function summarizeInput(name, input, filePath, command) {
+  if (filePath !== null) return filePath;
+  if (command !== null) return command.length > 100 ? `${command.slice(0, 100)}\u2026` : command;
+  if (input === null || typeof input !== "object") return "";
+  const o = input;
+  for (const key of ["pattern", "query", "path", "description", "prompt"]) {
+    const v = o[key];
+    if (typeof v === "string") return v.length > 100 ? `${v.slice(0, 100)}\u2026` : v;
+  }
+  const s = safeStringify(input);
+  return s.length > 100 ? `${s.slice(0, 100)}\u2026` : s;
+}
+function extractResultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => {
+      if (b !== null && typeof b === "object" && b["type"] === "text") {
+        const t = b["text"];
+        return typeof t === "string" ? t : "";
+      }
+      return "";
+    }).join("\n");
+  }
+  return "";
+}
+function* readFileLines(filePath) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const buf = Buffer.allocUnsafe(1 << 20);
+    const decoder = new StringDecoder("utf8");
+    let carry = "";
+    for (; ; ) {
+      const bytes = fs.readSync(fd, buf, 0, buf.length, null);
+      if (bytes === 0) break;
+      const lines = (carry + decoder.write(buf.subarray(0, bytes))).split("\n");
+      carry = lines.pop() ?? "";
+      for (const line of lines) yield line;
+    }
+    carry += decoder.end();
+    if (carry !== "") yield carry;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function parseTranscript(transcriptPath) {
+  const calls = [];
+  const resultTextById = /* @__PURE__ */ new Map();
+  const assistantTurns = [];
+  const resident = createResidentContextStats();
+  let seq = 0;
+  for (const line of readFileLines(transcriptPath)) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (obj === null || typeof obj !== "object") continue;
+    const o = obj;
+    accumulateResidentLine(resident, o, trimmed.length);
+    const message = o["message"];
+    if (message === null || typeof message !== "object") continue;
+    const messageObj = message;
+    const content = messageObj["content"];
+    if (!Array.isArray(content)) continue;
+    const role = typeof messageObj["role"] === "string" ? messageObj["role"] : null;
+    const cwd = typeof o["cwd"] === "string" ? o["cwd"] : null;
+    let turnTextTokens = 0;
+    let sawTextBlock = false;
+    for (const block of content) {
+      if (block === null || typeof block !== "object") continue;
+      const b = block;
+      if (b["type"] === "tool_use" && typeof b["id"] === "string" && typeof b["name"] === "string") {
+        const name = b["name"];
+        const input = b["input"];
+        const filePath = extractFilePath(name, input);
+        const command = extractCommand(name, input);
+        calls.push({
+          seq: seq++,
+          id: b["id"],
+          name,
+          input,
+          filePath,
+          command,
+          summary: summarizeInput(name, input, filePath, command),
+          cwd
+        });
+      } else if (b["type"] === "tool_result" && typeof b["tool_use_id"] === "string") {
+        const id = b["tool_use_id"];
+        if (!resultTextById.has(id)) {
+          resultTextById.set(id, extractResultText(b["content"]));
+        }
+      } else if (role === "assistant" && b["type"] === "text" && typeof b["text"] === "string") {
+        sawTextBlock = true;
+        turnTextTokens += estimateTokens(b["text"]);
+      }
+    }
+    if (role === "assistant" && sawTextBlock) assistantTurns.push(turnTextTokens);
+  }
+  return { calls, resultTextById, assistantTurns, resident };
+}
+function costPerCall(parsed) {
+  return parsed.calls.map((c) => ({
+    ...c,
+    tokens: estimateTokens(parsed.resultTextById.get(c.id) ?? "")
+  }));
+}
+function aggregateSortedDesc(pairs) {
+  return [...pairs].map(([key, tokens]) => ({ key, tokens })).sort((a, b) => b.tokens - a.tokens);
+}
+function tokensByTool(costs) {
+  const m = /* @__PURE__ */ new Map();
+  for (const c of costs) m.set(c.name, (m.get(c.name) ?? 0) + c.tokens);
+  return aggregateSortedDesc(m);
+}
+function tokensByFile(costs) {
+  const m = /* @__PURE__ */ new Map();
+  for (const c of costs) {
+    if (c.filePath === null) continue;
+    m.set(c.filePath, (m.get(c.filePath) ?? 0) + c.tokens);
+  }
+  return aggregateSortedDesc(m);
+}
+function topExpensiveCalls(costs, n) {
+  return [...costs].sort((a, b) => b.tokens - a.tokens).slice(0, n);
+}
+function neverTouchedAgain(costs) {
+  const readsByFile = /* @__PURE__ */ new Map();
+  for (const c of costs) {
+    if (c.name !== "Read" || c.filePath === null) continue;
+    const arr = readsByFile.get(c.filePath) ?? [];
+    arr.push(c);
+    readsByFile.set(c.filePath, arr);
+  }
+  const out = [];
+  for (const [filePath, reads] of readsByFile) {
+    const firstSeq = Math.min(...reads.map((r) => r.seq));
+    const touchedLater = costs.some((c) => {
+      if (c.seq <= firstSeq) return false;
+      if (c.filePath === filePath) return true;
+      return safeStringify(c.input).includes(filePath);
+    });
+    if (!touchedLater) {
+      out.push({ filePath, tokens: reads.reduce((n, r) => n + r.tokens, 0) });
+    }
+  }
+  return out.sort((a, b) => b.tokens - a.tokens);
+}
+async function repeatedUncompressedBashCommands(costs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of costs) {
+    if (c.name !== "Bash" || c.command === null) continue;
+    const norm = normalizeCommandForCacheKey(c.command);
+    const arr = groups.get(norm) ?? [];
+    arr.push(c);
+    groups.set(norm, arr);
+  }
+  const out = [];
+  for (const [norm, calls] of groups) {
+    if (calls.length < 2) continue;
+    let cached = false;
+    for (const c of calls) {
+      try {
+        const hash = await commandHash(c.command, c.cwd);
+        if (getBashOutput(hash) !== null) {
+          cached = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (cached) continue;
+    const totalTokens = calls.reduce((n, c) => n + c.tokens, 0);
+    out.push({
+      normalized: norm,
+      count: calls.length,
+      totalTokens,
+      avgTokens: Math.round(totalTokens / calls.length)
+    });
+  }
+  return out.sort((a, b) => b.totalTokens - a.totalTokens);
+}
+function assistantOutputCost(assistantTurns) {
+  const turnCount = assistantTurns.length;
+  let generatedTokens = 0;
+  let resendCeilingTokens = 0;
+  for (let i = 0; i < turnCount; i++) {
+    const tokens = assistantTurns[i] ?? 0;
+    generatedTokens += tokens;
+    resendCeilingTokens += tokens * (turnCount - 1 - i);
+  }
+  return { turnCount, generatedTokens, resendCeilingTokens };
+}
+async function buildWasteReport(transcriptPath, opts = {}) {
+  const parsed = parseTranscript(transcriptPath);
+  const costs = costPerCall(parsed);
+  const topN = opts.topN ?? 10;
+  return {
+    transcriptPath,
+    totalTokens: costs.reduce((n, c) => n + c.tokens, 0),
+    tokensByTool: tokensByTool(costs),
+    tokensByFile: tokensByFile(costs),
+    topCalls: topExpensiveCalls(costs, topN).map((c) => ({ seq: c.seq, name: c.name, summary: c.summary, tokens: c.tokens })),
+    neverTouchedAgain: neverTouchedAgain(costs),
+    repeatedUncompressedBash: await repeatedUncompressedBashCommands(costs),
+    assistantOutput: assistantOutputCost(parsed.assistantTurns),
+    residentContext: summarizeResidentContext(parsed.resident)
+  };
+}
+
+export {
+  projectTranscriptsDir,
+  findLatestTranscript,
+  safeStringify,
+  extractResultText,
+  readFileLines,
+  buildWasteReport
+};

package/dist/{token-goat-chunk-GYC34EGE.mjs → token-goat-chunk-KRPJIXCT.mjs}

@@ -2,10 +2,10 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   loadConfig
-} from "./token-goat-chunk-SOKAPOOC.mjs";
+} from "./token-goat-chunk-M6CDVASA.mjs";
 import {
   VERSION
-} from "./token-goat-chunk-ZGQXRYKE.mjs";
+} from "./token-goat-chunk-TGBSMHPM.mjs";
 import {
   displaySafeJson
 } from "./token-goat-chunk-NMTKNYGF.mjs";

package/dist/token-goat-chunk-KVAXTA2W.mjs

@@ -0,0 +1,198 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildCopilotWasteReport,
+  findProjectSession,
+  isCopilotTranscript
+} from "./token-goat-chunk-PPYZS7TI.mjs";
+import {
+  buildWasteReport
+} from "./token-goat-chunk-KQI24O4B.mjs";
+import "./token-goat-chunk-MQACN7VG.mjs";
+import "./token-goat-chunk-MEKVJZUN.mjs";
+import "./token-goat-chunk-M43UJVYQ.mjs";
+import "./token-goat-chunk-PHDNWISV.mjs";
+import "./token-goat-chunk-XQSSPX3X.mjs";
+import "./token-goat-chunk-2ZHD3XCD.mjs";
+import {
+  resolveProjectRoot
+} from "./token-goat-chunk-M6CDVASA.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-TGBSMHPM.mjs";
+import {
+  displaySafeJson
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_audit.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function buildFeedbackCardFromClaude(report) {
+  const preAudit = [];
+  const fixes = [];
+  if (report.neverTouchedAgain.length > 0) {
+    const files = report.neverTouchedAgain.map((f) => path.basename(f.filePath)).join(", ");
+    preAudit.push(`Whole-file reads without reuse: ${files} (${report.neverTouchedAgain.length} file(s) read once via Read)`);
+    fixes.push('Prefer `token-goat symbol` or `read "file::symbol"` instead of reading whole files.');
+  }
+  if (report.repeatedUncompressedBash.length > 0) {
+    const cmds = report.repeatedUncompressedBash.map((b) => `"${b.normalized.slice(0, 40)}" (${b.count}x)`).join(", ");
+    preAudit.push(`Repeated uncompressed terminal commands: ${cmds}`);
+    fixes.push("Use token-goat bash-output cache or compress flags for repetitive terminal invocations.");
+  }
+  if (preAudit.length === 0) {
+    preAudit.push("Pre-audit session: No missed surgical reads or friction detected; gate adhered to cleanly.");
+  }
+  if (fixes.length === 0) {
+    fixes.push("Maintain current surgical read and caching discipline.");
+  }
+  return {
+    taskSummary: `Engineering session in project (${report.totalTokens.toLocaleString()} tokens recorded across tool invocations).`,
+    preAuditFindings: preAudit,
+    auditExecutionFindings: [],
+    recommendedFix: fixes
+  };
+}
+function buildFeedbackCardFromCopilot(report) {
+  const preAudit = [];
+  const fixes = [];
+  const repeatedBlocks = report.blocks.filter((b) => b.repeatCount > 0);
+  if (repeatedBlocks.length > 0) {
+    const kinds = repeatedBlocks.map((b) => `${b.kind} (${b.repeatCount}x repeat, ${b.repeatBytes} B)`).join(", ");
+    preAudit.push(`Repeated prompt blocks across turns: ${kinds}`);
+    fixes.push("Deduplicate repeated prompt instructions or context blocks across turns.");
+  }
+  if (report.mcpTools && report.mcpTools.servers.length > 0) {
+    const totalMcpTokens = report.mcpTools.servers.reduce((sum, s) => sum + s.estimatedTokens, 0);
+    const heavy = report.mcpTools.servers.filter((s) => s.estimatedTokens > 1e3);
+    if (heavy.length > 0 || totalMcpTokens > 1500) {
+      const details = report.mcpTools.servers.map((s) => `${s.serverName} (${s.toolCount} tool(s), ~${s.estimatedTokens.toLocaleString()} tok/turn)`).join(", ");
+      const turns = Math.max(1, report.turns);
+      const cumulative = totalMcpTokens * turns;
+      preAudit.push(
+        `High fixed MCP tool definition overhead: ${details}; total ~${totalMcpTokens.toLocaleString()} tok/turn re-sent across ${turns} turn(s) (~${cumulative.toLocaleString()} cumulative tokens).`
+      );
+      const heavyNames = (heavy.length > 0 ? heavy : report.mcpTools.servers).map((s) => s.serverName).join(", ");
+      fixes.push(
+        `Disable unused MCP server(s) (${heavyNames}) via 'copilot mcp disable <name>' or exclude individual tools with '--excluded-tools'.`
+      );
+    }
+  }
+  if (preAudit.length === 0) {
+    preAudit.push("Pre-audit session: No missed surgical reads or friction detected; gate adhered to cleanly.");
+  }
+  if (fixes.length === 0) {
+    fixes.push("Maintain current token-efficient tooling and MCP server configuration.");
+  }
+  return {
+    taskSummary: `Copilot CLI session (${report.turns} turn(s) recorded in ${report.sessionId}).`,
+    preAuditFindings: preAudit,
+    auditExecutionFindings: [],
+    recommendedFix: fixes
+  };
+}
+function formatMaintainerCard(card) {
+  const lines = [
+    "Maintainer Feedback Card",
+    "",
+    `\u2022 Task Summary: ${card.taskSummary}`,
+    "\u2022 Friction & Missed Savings:"
+  ];
+  for (const f of card.preAuditFindings) {
+    lines.push(`  - ${f}`);
+  }
+  if (card.auditExecutionFindings.length > 0) {
+    for (const a of card.auditExecutionFindings) {
+      lines.push(`  - Audit Execution: ${a}`);
+    }
+  }
+  lines.push("\u2022 Recommended Fix:");
+  for (const r of card.recommendedFix) {
+    lines.push(`  - ${r}`);
+  }
+  return lines.join("\n") + "\n";
+}
+async function runAuditCommand(opts = {}) {
+  const projectRoot = resolveProjectRoot(opts.project !== void 0 ? { project: opts.project } : {});
+  if (opts.transcript !== void 0) {
+    const resolved = path.resolve(opts.transcript);
+    if (!fs.existsSync(resolved)) {
+      const err = `transcript not found: ${resolved}`;
+      if (opts.json === true) {
+        process.stdout.write(`${displaySafeJson({ error: err }, 0)}
+`);
+      } else {
+        process.stderr.write(`token-goat: ${err}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (isCopilotTranscript(resolved)) {
+      const report3 = buildCopilotWasteReport(resolved);
+      const card3 = buildFeedbackCardFromCopilot(report3);
+      if (opts.json === true) {
+        process.stdout.write(`${displaySafeJson(card3, 0)}
+`);
+      } else {
+        process.stdout.write(formatMaintainerCard(card3));
+      }
+      return;
+    }
+    const report2 = await buildWasteReport(resolved);
+    const card2 = buildFeedbackCardFromClaude(report2);
+    if (opts.json === true) {
+      process.stdout.write(`${displaySafeJson(card2, 0)}
+`);
+    } else {
+      process.stdout.write(formatMaintainerCard(card2));
+    }
+    return;
+  }
+  const detected = findProjectSession(projectRoot);
+  if (detected === null) {
+    const err = "no session transcript found for project";
+    if (opts.json === true) {
+      process.stdout.write(`${displaySafeJson({ error: err, project: projectRoot }, 0)}
+`);
+    } else {
+      process.stdout.write(`
+# token-goat audit
+Project: ${projectRoot}
+No session transcript found. Pass --transcript <path> to specify one explicitly.
+`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (detected.kind === "copilot") {
+    const report2 = buildCopilotWasteReport(detected.path);
+    const card2 = buildFeedbackCardFromCopilot(report2);
+    if (opts.json === true) {
+      process.stdout.write(`${displaySafeJson(card2, 0)}
+`);
+    } else {
+      process.stdout.write(formatMaintainerCard(card2));
+    }
+    return;
+  }
+  const report = await buildWasteReport(detected.path);
+  const card = buildFeedbackCardFromClaude(report);
+  if (opts.json === true) {
+    process.stdout.write(`${displaySafeJson(card, 0)}
+`);
+  } else {
+    process.stdout.write(formatMaintainerCard(card));
+  }
+}
+export {
+  buildFeedbackCardFromClaude,
+  buildFeedbackCardFromCopilot,
+  formatMaintainerCard,
+  runAuditCommand
+};

package/dist/{token-goat-chunk-FJZ5MZK7.mjs → token-goat-chunk-LK3YOKDF.mjs}

@@ -3,7 +3,7 @@ const require = __cjsRequire(import.meta.url);
 import {
   queryCsv,
   quoteCsvCell
-} from "./token-goat-chunk-KWM6KBPA.mjs";
+} from "./token-goat-chunk-SHV6QQAS.mjs";
 import {
   NotAnOfficeDocumentError,
   assertOoxmlWithinDeadline,
@@ -12,7 +12,7 @@ import {
   ooxmlWorkDeadline,
   parseOoxmlPart,
   readOoxmlZip
-} from "./token-goat-chunk-BTKDZW7F.mjs";
+} from "./token-goat-chunk-QTIRVK3M.mjs";
 import {
   displaySafeText
 } from "./token-goat-chunk-NMTKNYGF.mjs";