token-goat 2.9.19 → 2.9.20

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

@@ -0,0 +1,304 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  findLatestTranscript,
+  readFileLines
+} from "./token-goat-chunk-BQIC3AVL.mjs";
+import {
+  copilotCliUserRoot,
+  readCopilotMcpTools
+} from "./token-goat-chunk-SP5QR2HN.mjs";
+import {
+  canonicalize
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/copilot_waste.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var HOOK_RECORD_TYPES = /* @__PURE__ */ new Set(["hook.start", "hook.end"]);
+function splitInjectedBlocks(transformed) {
+  const out = [];
+  const blockRe = /<([a-z_][a-z0-9_]*)>([\s\S]*?)<\/\1>/gi;
+  let m;
+  while ((m = blockRe.exec(transformed)) !== null) {
+    const tag = (m[1] ?? "").toLowerCase();
+    const body = m[2] ?? "";
+    let kind = tag;
+    if (tag === "system_reminder") {
+      const inner = /^\s*<([a-z_][a-z0-9_]*)>/i.exec(body);
+      kind = inner !== null ? `reminder:${(inner[1] ?? "").toLowerCase()}` : "reminder:text";
+    }
+    out.push({ kind, body: m[0] });
+  }
+  return out;
+}
+function pathsMatch(a, b) {
+  if (a === void 0 || b === void 0 || a === "" || b === "") return false;
+  return canonicalize(a) === canonicalize(b);
+}
+function readCopilotWorkspace(sessionDir) {
+  const wsFile = path.join(sessionDir, "workspace.yaml");
+  let raw;
+  try {
+    raw = fs.readFileSync(wsFile, "utf8");
+  } catch {
+    return null;
+  }
+  let cwd;
+  let gitRoot;
+  let id;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("cwd:")) {
+      cwd = trimmed.slice(4).trim().replace(/^['"]|['"]$/g, "");
+    } else if (trimmed.startsWith("git_root:")) {
+      gitRoot = trimmed.slice(9).trim().replace(/^['"]|['"]$/g, "");
+    } else if (trimmed.startsWith("id:")) {
+      id = trimmed.slice(3).trim().replace(/^['"]|['"]$/g, "");
+    }
+  }
+  return { cwd, gitRoot, id };
+}
+function isProcessAlive(pid) {
+  if (pid <= 0 || !Number.isInteger(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function isCopilotSessionActive(sessionDir, sessionId) {
+  const sid = sessionId ?? path.basename(sessionDir);
+  const envSessionId = process.env["COPILOT_AGENT_SESSION_ID"];
+  if (envSessionId !== void 0 && envSessionId.trim() === sid) {
+    return true;
+  }
+  try {
+    const files = fs.readdirSync(sessionDir);
+    for (const f of files) {
+      if (f.startsWith("inuse.") && f.endsWith(".lock")) {
+        const pidStr = f.slice(6, -5);
+        const pid = parseInt(pidStr, 10);
+        if (!Number.isNaN(pid) && isProcessAlive(pid)) {
+          return true;
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const opLock = path.join(path.dirname(sessionDir), ".session-operation-locks", `${sid}.lock`);
+    if (fs.existsSync(opLock)) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function isCopilotTranscript(filePath) {
+  if (path.basename(filePath) === "events.jsonl") return true;
+  try {
+    const fd = fs.openSync(filePath, "r");
+    const buf = Buffer.alloc(512);
+    const bytesRead = fs.readSync(fd, buf, 0, 512, 0);
+    fs.closeSync(fd);
+    const prefix = buf.toString("utf8", 0, bytesRead);
+    return /"type"\s*:\s*"(?:session\.|user\.message|assistant\.message|tool\.)/.test(prefix);
+  } catch {
+    return false;
+  }
+}
+function findActiveCopilotSession(projectRoot) {
+  return findLatestCopilotSession({ projectRoot, onlyActive: true });
+}
+function findLatestCopilotSession(projectRootOrOpts) {
+  const opts = typeof projectRootOrOpts === "string" ? { projectRoot: projectRootOrOpts } : projectRootOrOpts ?? {};
+  const root = path.join(copilotCliUserRoot(), "session-state");
+  const envSessionId = process.env["COPILOT_AGENT_SESSION_ID"];
+  if (envSessionId !== void 0 && envSessionId.trim() !== "") {
+    const sid = envSessionId.trim();
+    const sessionDir = path.join(root, sid);
+    const candidate = path.join(sessionDir, "events.jsonl");
+    if (fs.existsSync(candidate)) {
+      try {
+        if (fs.statSync(candidate).isFile()) {
+          if (opts.projectRoot !== void 0) {
+            const ws = readCopilotWorkspace(sessionDir);
+            if (ws && (pathsMatch(ws.cwd, opts.projectRoot) || pathsMatch(ws.gitRoot, opts.projectRoot))) {
+              return candidate;
+            }
+          } else {
+            return candidate;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(root);
+  } catch {
+    return null;
+  }
+  let bestActive = null;
+  let bestActiveMtime = -Infinity;
+  let bestInactive = null;
+  let bestInactiveMtime = -Infinity;
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    const sessionDir = path.join(root, entry);
+    const candidate = path.join(sessionDir, "events.jsonl");
+    let st;
+    try {
+      st = fs.statSync(candidate);
+      if (!st.isFile()) continue;
+    } catch {
+      continue;
+    }
+    if (opts.projectRoot !== void 0) {
+      const ws = readCopilotWorkspace(sessionDir);
+      if (!ws || !pathsMatch(ws.cwd, opts.projectRoot) && !pathsMatch(ws.gitRoot, opts.projectRoot)) {
+        continue;
+      }
+    }
+    const active = isCopilotSessionActive(sessionDir, entry);
+    if (active) {
+      if (st.mtimeMs > bestActiveMtime) {
+        bestActiveMtime = st.mtimeMs;
+        bestActive = candidate;
+      }
+    } else if (opts.onlyActive !== true) {
+      if (st.mtimeMs > bestInactiveMtime) {
+        bestInactiveMtime = st.mtimeMs;
+        bestInactive = candidate;
+      }
+    }
+  }
+  return bestActive ?? (opts.onlyActive === true ? null : bestInactive);
+}
+function findProjectSession(projectRoot) {
+  const copilotSession = findActiveCopilotSession(projectRoot) ?? findLatestCopilotSession(projectRoot);
+  const claudeTranscript = findLatestTranscript(projectRoot);
+  if (copilotSession !== null && claudeTranscript !== null) {
+    if (findActiveCopilotSession(projectRoot) !== null) {
+      return { path: copilotSession, kind: "copilot" };
+    }
+    let cpTime = 0;
+    let clTime = 0;
+    try {
+      cpTime = fs.statSync(copilotSession).mtimeMs;
+    } catch {
+    }
+    try {
+      clTime = fs.statSync(claudeTranscript).mtimeMs;
+    } catch {
+    }
+    return cpTime >= clTime ? { path: copilotSession, kind: "copilot" } : { path: claudeTranscript, kind: "claude" };
+  }
+  if (copilotSession !== null) {
+    return { path: copilotSession, kind: "copilot" };
+  }
+  if (claudeTranscript !== null) {
+    return { path: claudeTranscript, kind: "claude" };
+  }
+  return null;
+}
+function readNumber(source, key) {
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function buildCopilotWasteReport(eventsPath) {
+  const report = {
+    sessionPath: eventsPath,
+    sessionId: path.basename(path.dirname(eventsPath)),
+    turns: 0,
+    tokens: null,
+    blocks: [],
+    compactions: [],
+    hookRecordBytes: 0,
+    // Measured off the file rather than off a string of its contents: an event log large enough for this number to matter is exactly the one readFileSync cannot return, since V8 caps a string at about 512 MB.
+    totalEventBytes: fs.statSync(eventsPath).size,
+    // Read through the real resolution chain rather than passed in. Copilot's
+    // own COPILOT_CACHE_HOME override is what tests point at a fixture, so the
+    // shipping path is the tested path and there is no seam here that only a
+    // test ever supplies.
+    mcpTools: readCopilotMcpTools()
+  };
+  const classes = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  for (const line of readFileLines(eventsPath)) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const type = typeof event["type"] === "string" ? event["type"] : "";
+    const data = event["data"] ?? {};
+    if (HOOK_RECORD_TYPES.has(type)) {
+      report.hookRecordBytes += Buffer.byteLength(trimmed, "utf-8");
+      continue;
+    }
+    if (type === "session.shutdown") {
+      report.tokens = {
+        systemTokens: readNumber(data, "systemTokens"),
+        toolDefinitionsTokens: readNumber(data, "toolDefinitionsTokens"),
+        conversationTokens: readNumber(data, "conversationTokens"),
+        currentTokens: readNumber(data, "currentTokens")
+      };
+      continue;
+    }
+    if (type === "session.compaction_complete") {
+      const summary = typeof data["summaryContent"] === "string" ? data["summaryContent"] : "";
+      report.compactions.push({
+        trigger: typeof data["trigger"] === "string" ? data["trigger"] : "unknown",
+        summaryBytes: Buffer.byteLength(summary, "utf-8"),
+        preTokens: readNumber(data, "preCompactionTokens"),
+        postTokens: readNumber(data, "postCompactionTokens")
+      });
+      continue;
+    }
+    if (type !== "user.message") continue;
+    const transformed = typeof data["transformedContent"] === "string" ? data["transformedContent"] : "";
+    if (transformed === "") continue;
+    report.turns += 1;
+    for (const block of splitInjectedBlocks(transformed)) {
+      const bytes = Buffer.byteLength(block.body, "utf-8");
+      let cls = classes.get(block.kind);
+      if (cls === void 0) {
+        cls = { kind: block.kind, count: 0, bytes: 0, repeatBytes: 0, repeatCount: 0 };
+        classes.set(block.kind, cls);
+      }
+      cls.count += 1;
+      cls.bytes += bytes;
+      let bucket = seen.get(block.kind);
+      if (bucket === void 0) {
+        bucket = /* @__PURE__ */ new Set();
+        seen.set(block.kind, bucket);
+      }
+      if (bucket.has(block.body)) {
+        cls.repeatBytes += bytes;
+        cls.repeatCount += 1;
+      } else {
+        bucket.add(block.body);
+      }
+    }
+  }
+  report.blocks = [...classes.values()].sort((a, b) => b.bytes - a.bytes);
+  return report;
+}
+
+export {
+  isCopilotTranscript,
+  findLatestCopilotSession,
+  findProjectSession,
+  buildCopilotWasteReport
+};