@astudioplus/compressor 0.1.0

package/dist/copilot-hook.js

@@ -0,0 +1,1000 @@
+// src/copilot-hook-entry.ts
+import process3 from "node:process";
+
+// src/engine/types.ts
+var OMISSION_MARKER = "[compressor:";
+
+// src/engine/detect.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "rs",
+  "py",
+  "go",
+  "java",
+  "c",
+  "h",
+  "cpp",
+  "hpp",
+  "rb",
+  "php",
+  "swift",
+  "kt",
+  "scala",
+  "sh",
+  "zsh",
+  "css",
+  "scss",
+  "sql",
+  "toml",
+  "yaml",
+  "yml"
+]);
+var TEST_LOG_RES = [
+  /^(PASS|FAIL)\s/m,
+  /^Tests:\s/m,
+  /\d+\s+pass(?:ed|ing)\b/,
+  /\d+\s+fail(?:ed|ing)\b/,
+  /^test result:/m,
+  /--- FAIL/,
+  /^test\s+\S+\s+\.\.\.\s+(?:ok|FAILED)\s*$/m,
+  // node:test spec ('ℹ pass 118') and tap ('# pass 118') summary counters
+  /^(?:ℹ|#) (?:tests|suites|pass|fail|cancelled|skipped|todo) \d+\s*$/m
+];
+var BUILD_LOG_RES = [
+  /error\[E\d+\]/,
+  /^\s*(error|warning)(\s+TS\d+)?:/m,
+  /\bCompiling\s/,
+  /npm ERR!/
+];
+var STACK_FRAME_RE = /^\s+at .+:\d+:\d+/m;
+function detectKind(content, filePath) {
+  if (filePath !== void 0) {
+    const ext = extensionOf(filePath);
+    if (ext !== void 0 && CODE_EXTENSIONS.has(ext)) return "code";
+  }
+  if (content.startsWith("#!")) return "code";
+  if (TEST_LOG_RES.some((re) => re.test(content))) return "test-log";
+  if (BUILD_LOG_RES.some((re) => re.test(content))) return "build-log";
+  if (STACK_FRAME_RE.test(content) && /\berror\b/i.test(content)) return "build-log";
+  return "generic";
+}
+function extensionOf(filePath) {
+  const match = /\.([A-Za-z0-9]+)$/.exec(filePath);
+  return match?.[1]?.toLowerCase();
+}
+
+// src/engine/tiers/structural.ts
+function tierResult(before, after, id) {
+  if (after === before) return { content: before };
+  return { content: after, transform: { id, charsSaved: before.length - after.length } };
+}
+var ANSI_RE = /\u001b\[[0-9;:<=>?]*[ -\/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-_]/g;
+var CONTROL_RE = /[\u0000-\u0008\u000b-\u001f\u007f]/g;
+function stripAnsi(content) {
+  const next = content.replace(ANSI_RE, "").replace(CONTROL_RE, "");
+  return tierResult(content, next, "strip-ansi");
+}
+var BLANK_RE = /^[ \t]*$/;
+function collapseBlankRuns(content) {
+  const lines = content.split("\n");
+  const out = [];
+  let run = [];
+  const flush = () => {
+    if (run.length === 0) return;
+    if (run.length >= 3) out.push("");
+    else out.push(...run);
+    run = [];
+  };
+  for (const line of lines) {
+    if (BLANK_RE.test(line)) {
+      run.push(line);
+      continue;
+    }
+    flush();
+    out.push(line);
+  }
+  flush();
+  return tierResult(content, out.join("\n"), "collapse-blank");
+}
+function dedupeLines(content) {
+  const lines = content.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === void 0) break;
+    let run = 1;
+    while (i + run < lines.length && lines[i + run] === line) run += 1;
+    if (run >= 3 && line.trim() !== "") {
+      out.push(line, `[compressor: previous line repeated ${run - 1} more times]`);
+    } else {
+      for (let k = 0; k < run; k += 1) out.push(line);
+    }
+    i += run;
+  }
+  return tierResult(content, out.join("\n"), "dedupe-lines");
+}
+var LINE_NUM_CAPTURE_RE = /^ *(\d+)(?:→|\t)/;
+function lineNumberOf(line) {
+  const digits = LINE_NUM_CAPTURE_RE.exec(line)?.[1];
+  return digits === void 0 ? void 0 : Number(digits);
+}
+var FAILURE_LINE_RE = /\b(error|fail(ed|ure)?|warn(ing)?|exception|panic|fatal)\b/i;
+function scanFailureLines(lines, firstFileLine) {
+  let count = 0;
+  const found = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line === void 0 || line.includes(OMISSION_MARKER)) continue;
+    if (!FAILURE_LINE_RE.test(line)) continue;
+    count += 1;
+    if (found.length < 3) {
+      const n = lineNumberOf(line) ?? (firstFileLine === void 0 ? void 0 : firstFileLine + i);
+      if (n !== void 0) found.push(n);
+    }
+  }
+  return { count, lines: found };
+}
+function formatMatchLines(scan) {
+  return scan.lines.join(", ") + (scan.count > 3 ? " (first 3)" : "");
+}
+function omissionMarker(a, b, estTokens, meta, style, omittedLines) {
+  const head = `[compressor: lines ${a}-${b} omitted (~${estTokens} est tokens)`;
+  const limit = b - a + 1;
+  if (meta.tool === "read" && meta.filePath !== void 0) {
+    const file = meta.filePath;
+    if (style === "deterrent") {
+      return `${head} \u2014 likely irrelevant; Read ${file} offset=${a} limit=${limit} ONLY if the problem you are chasing points into this range]`;
+    }
+    if (style === "informative") {
+      const scan = scanFailureLines(omittedLines, a);
+      if (scan.count === 0) {
+        return `${head} \u2014 no error/failure/warning lines in the omitted range; safe to skip. Read ${file} offset=${a} limit=${limit} only if needed]`;
+      }
+      const nearest = scan.lines[0] ?? a;
+      return `${head} \u2014 ${scan.count} lines matching error/fail/warn at lines ${formatMatchLines(scan)} \u2014 Read ${file} offset=${nearest} limit=20 for the nearest match; full range offset=${a} limit=${limit}]`;
+    }
+    return `${head} \u2014 Read ${file} with offset=${a} and limit=${limit} to retrieve]`;
+  }
+  if (style === "deterrent") {
+    return `${head} \u2014 likely irrelevant; re-run with a narrower filter (grep, --quiet, head) ONLY if the problem you are chasing points into this range]`;
+  }
+  if (style === "informative") {
+    const scan = scanFailureLines(omittedLines, a);
+    if (scan.count === 0) {
+      return `${head} \u2014 no error/failure/warning lines in the omitted range; safe to skip. Re-run with a narrower filter (grep, --quiet, head) only if needed]`;
+    }
+    return `${head} \u2014 ${scan.count} lines matching error/fail/warn at lines ${formatMatchLines(scan)} \u2014 re-run with a narrower filter (grep, --quiet, head) to retrieve]`;
+  }
+  return `${head} \u2014 re-run with a narrower filter (grep, --quiet, head) to retrieve]`;
+}
+function countMarker(count, unit, estTokens, meta, style, omitted) {
+  const head = `[compressor: ${count} ${unit} omitted (~${estTokens} est tokens)`;
+  if (meta.tool === "read" && meta.filePath !== void 0) {
+    const file = meta.filePath;
+    if (style === "deterrent") {
+      return `${head} \u2014 likely irrelevant; Read ${file} ONLY if the problem you are chasing points into the omitted content]`;
+    }
+    if (style === "informative") {
+      const matches = scanFailureLines(omitted.split("\n")).count;
+      return matches === 0 ? `${head} \u2014 no error/failure/warning lines in the omitted content; safe to skip. Read ${file} only if needed]` : `${head} \u2014 ${matches} lines matching error/fail/warn in the omitted content \u2014 Read ${file} to retrieve]`;
+    }
+    return `${head} \u2014 Read ${file} to retrieve]`;
+  }
+  if (style === "deterrent") {
+    return `${head} \u2014 likely irrelevant; re-run with a narrower filter (grep, --quiet, head) ONLY if the problem you are chasing points into the omitted content]`;
+  }
+  if (style === "informative") {
+    const matches = scanFailureLines(omitted.split("\n")).count;
+    return matches === 0 ? `${head} \u2014 no error/failure/warning lines in the omitted content; safe to skip. Re-run with a narrower filter (grep, --quiet, head) only if needed]` : `${head} \u2014 ${matches} lines matching error/fail/warn in the omitted content \u2014 re-run with a narrower filter (grep, --quiet, head) to retrieve]`;
+  }
+  return `${head} \u2014 re-run with a narrower filter (grep, --quiet, head) to retrieve]`;
+}
+function truncateChars(content, meta, policy, estimate) {
+  const est = estimate(content);
+  const ratio = policy.truncateBudget / est;
+  const headChars = Math.max(1, Math.floor(content.length * ratio * 0.6));
+  const tailChars = Math.max(1, Math.floor(content.length * ratio * 0.4));
+  if (headChars + tailChars >= content.length) return { content };
+  const omitted = content.slice(headChars, content.length - tailChars);
+  const marker = countMarker(
+    omitted.length,
+    "chars",
+    estimate(omitted),
+    meta,
+    policy.markerStyle,
+    omitted
+  );
+  const next = `${content.slice(0, headChars)}
+${marker}
+${content.slice(content.length - tailChars)}`;
+  return tierResult(content, next, "truncate");
+}
+function truncateHeadTail(content, meta, policy, estimate, positionsAreFileLines = true) {
+  const est = estimate(content);
+  if (est <= policy.truncateBudget) return { content };
+  const lines = content.split("\n");
+  const total = lines.length;
+  const ratio = policy.truncateBudget / est;
+  const keep = Math.max(2, Math.floor(total * ratio));
+  if (keep >= total) return truncateChars(content, meta, policy, estimate);
+  const headCount = Math.max(1, Math.floor(keep * 0.6));
+  const tailCount = Math.max(1, keep - headCount);
+  const omitStart = headCount + 1;
+  const omitEnd = total - tailCount;
+  if (omitEnd < omitStart) return { content };
+  const omittedLines = lines.slice(headCount, total - tailCount);
+  const omitted = omittedLines.join("\n");
+  const estOmitted = estimate(omitted);
+  const a = lineNumberOf(omittedLines[0] ?? "");
+  const b = lineNumberOf(omittedLines[omittedLines.length - 1] ?? "");
+  const marker = a !== void 0 && b !== void 0 && a <= b ? omissionMarker(a, b, estOmitted, meta, policy.markerStyle, omittedLines) : positionsAreFileLines ? omissionMarker(omitStart, omitEnd, estOmitted, meta, policy.markerStyle, omittedLines) : countMarker(omittedLines.length, "lines", estOmitted, meta, policy.markerStyle, omitted);
+  const next = [...lines.slice(0, headCount), marker, ...lines.slice(total - tailCount)].join("\n");
+  return tierResult(content, next, "truncate");
+}
+
+// src/engine/tiers/code.ts
+var LANG_BY_EXT = {
+  ts: "ts-js",
+  tsx: "ts-js",
+  js: "ts-js",
+  jsx: "ts-js",
+  mjs: "ts-js",
+  cjs: "ts-js",
+  rs: "rust",
+  py: "python",
+  go: "go",
+  java: "c-like",
+  c: "c-like",
+  h: "c-like",
+  cpp: "c-like",
+  hpp: "c-like",
+  swift: "c-like",
+  kt: "c-like",
+  scala: "c-like",
+  php: "c-like",
+  rb: "ruby",
+  sh: "shell",
+  zsh: "shell",
+  css: "css",
+  scss: "css",
+  sql: "sql",
+  toml: "config",
+  yaml: "config",
+  yml: "config"
+};
+function langFromPath(filePath) {
+  if (filePath === void 0) return void 0;
+  const match = /\.([A-Za-z0-9]+)$/.exec(filePath);
+  const ext = match?.[1]?.toLowerCase();
+  return ext === void 0 ? void 0 : LANG_BY_EXT[ext];
+}
+var LINE_NUM_RE = /^ *\d+(?:→|\t)/;
+function hasLineNumbers(content) {
+  const lines = content.split("\n").filter((l) => l.length > 0);
+  if (lines.length < 2) return false;
+  return lines.every((l) => LINE_NUM_RE.test(l));
+}
+function lineText(line) {
+  const match = LINE_NUM_RE.exec(line);
+  return match === null ? line : line.slice(match[0].length);
+}
+var COMMENT_SYNTAX = {
+  "ts-js": { line: ["//"], block: { open: "/*", close: "*/" } },
+  rust: { line: ["//"], block: { open: "/*", close: "*/" } },
+  python: { line: ["#"] },
+  go: { line: ["//"], block: { open: "/*", close: "*/" } },
+  "c-like": { line: ["//"], block: { open: "/*", close: "*/" } },
+  ruby: { line: ["#"] },
+  shell: { line: ["#"] },
+  css: { line: ["//"], block: { open: "/*", close: "*/" } },
+  sql: { line: ["--"], block: { open: "/*", close: "*/" } },
+  config: { line: ["#"] }
+};
+function scanPythonTriples(text, open) {
+  let state = open;
+  let i = 0;
+  while (i < text.length) {
+    if (state === null) {
+      const dq = text.indexOf('"""', i);
+      const sq = text.indexOf("'''", i);
+      const next = dq === -1 ? sq : sq === -1 ? dq : Math.min(dq, sq);
+      if (next === -1) break;
+      state = text.startsWith('"""', next) ? '"""' : "'''";
+      i = next + 3;
+    } else {
+      const close = text.indexOf(state, i);
+      if (close === -1) break;
+      i = close + 3;
+      state = null;
+    }
+  }
+  return state;
+}
+function commentStripMarker(stripped, strippedLines, style) {
+  const head = `[compressor: ${stripped} comment/blank lines stripped \u2014 line numbers preserved`;
+  if (style === "deterrent") {
+    return `${head}; comments are likely irrelevant to the problem you are chasing]`;
+  }
+  if (style === "informative") {
+    const scan = scanFailureLines(strippedLines);
+    return scan.count === 0 ? `${head}; no error/failure/warning text among them; safe to skip]` : `${head}; ${scan.count} stripped lines matching error/fail/warn at lines ${formatMatchLines(scan)}]`;
+  }
+  return `${head}]`;
+}
+function stripComments(content, lang, style = "plain") {
+  if (lang === void 0 || !hasLineNumbers(content)) return { content };
+  if (lang === "config") return { content };
+  const syntax = COMMENT_SYNTAX[lang];
+  const block = syntax.block;
+  const lines = content.split("\n");
+  const kept = [];
+  const strippedLines = [];
+  let stripped = 0;
+  let inBlock = false;
+  let tripleOpen = null;
+  for (const line of lines) {
+    if (line.length === 0) {
+      kept.push(line);
+      continue;
+    }
+    const text = lineText(line);
+    if (lang === "python" && tripleOpen !== null) {
+      tripleOpen = scanPythonTriples(text, tripleOpen);
+      kept.push(line);
+      continue;
+    }
+    const trimmed = text.trim();
+    let drop = false;
+    if (inBlock && block !== void 0) {
+      const closeIdx = trimmed.indexOf(block.close);
+      if (closeIdx >= 0) {
+        inBlock = false;
+        drop = trimmed.slice(closeIdx + block.close.length).trim() === "";
+      } else {
+        drop = true;
+      }
+    } else if (trimmed === "") {
+      drop = true;
+    } else if (trimmed.startsWith("#!")) {
+      drop = false;
+    } else if (syntax.line.some((p) => trimmed.startsWith(p))) {
+      drop = true;
+    } else if (block !== void 0 && trimmed.startsWith(block.open)) {
+      const rest = trimmed.slice(block.open.length);
+      const closeIdx = rest.indexOf(block.close);
+      if (closeIdx >= 0) {
+        drop = rest.slice(closeIdx + block.close.length).trim() === "";
+      } else {
+        drop = true;
+        inBlock = true;
+      }
+    }
+    if (drop) {
+      stripped += 1;
+      strippedLines.push(line);
+    } else {
+      if (lang === "python") tripleOpen = scanPythonTriples(text, null);
+      kept.push(line);
+    }
+  }
+  if (stripped === 0) return { content };
+  const marker = commentStripMarker(stripped, strippedLines, style);
+  const trailing = kept.length > 0 && kept[kept.length - 1] === "" ? kept.pop() : void 0;
+  kept.push(marker);
+  if (trailing !== void 0) kept.push(trailing);
+  return tierResult(content, kept.join("\n"), "comment-strip");
+}
+var SIGNATURE_TESTS = {
+  "ts-js": (t) => /^(import|export|function|async function|class|interface|type)\b/.test(t),
+  rust: (t) => /^\s*(use|pub|fn|struct|enum|trait|impl|mod)\b/.test(t),
+  python: (t) => /^\s*(import|from|def|class|async def)\b/.test(t),
+  go: (t) => /^(package|import|func|type)\b/.test(t)
+};
+function skeleton(content, lang, meta, estimate, style = "plain") {
+  if (lang === void 0 || !hasLineNumbers(content)) return { content };
+  const isSignature = SIGNATURE_TESTS[lang];
+  if (isSignature === void 0) return { content };
+  const lines = content.split("\n");
+  const out = [];
+  let gap = [];
+  const flushGap = () => {
+    if (gap.length === 0) return;
+    const first = gap[0];
+    const last = gap[gap.length - 1];
+    const a = first === void 0 ? void 0 : lineNumberOf(first);
+    const b = last === void 0 ? void 0 : lineNumberOf(last);
+    if (gap.length < 2 || a === void 0 || b === void 0) {
+      out.push(...gap);
+    } else {
+      out.push(omissionMarker(a, b, estimate(gap.join("\n")), meta, style, gap));
+    }
+    gap = [];
+  };
+  for (const line of lines) {
+    if (line.length === 0) {
+      flushGap();
+      out.push(line);
+      continue;
+    }
+    if (isSignature(lineText(line))) {
+      flushGap();
+      out.push(line);
+    } else {
+      gap.push(line);
+    }
+  }
+  flushGap();
+  return tierResult(content, out.join("\n"), "skeleton");
+}
+
+// src/engine/tiers/logs.ts
+function logMarker(noun, omittedLines, style) {
+  const head = `[compressor: ${omittedLines.length} ${noun} lines omitted`;
+  if (style === "deterrent") {
+    return `${head} \u2014 likely irrelevant; re-run with a narrower filter ONLY if the problem you are chasing points into the omitted output]`;
+  }
+  if (style === "informative") {
+    const matches = scanFailureLines(omittedLines).count;
+    return matches === 0 ? `${head} \u2014 no error/failure/warning lines in the omitted output; safe to skip. Re-run with a narrower filter only if needed]` : `${head} \u2014 ${matches} omitted lines matching error/fail/warn \u2014 re-run with a narrower filter to retrieve]`;
+  }
+  return `${head}]`;
+}
+var TEST_PASS_RES = [
+  /^\s*[✓✔√]\s/,
+  /^PASS\s/,
+  /^\s*--- PASS:/,
+  /^test\s+\S+\s+\.\.\.\s+ok\s*$/,
+  /\bPASSED\s*$/,
+  /^ok\s+\d+\s/
+];
+var TEST_FAIL_RES = [
+  /^\s*[✗✘✖×]\s/,
+  /^FAIL\b/,
+  /--- FAIL/,
+  /\bFAILED\b/,
+  /^not ok\s/,
+  /\bpanicked\b/,
+  /^\s*●/,
+  // error reports only ('Error: boom', 'error: x'), not prose containing 'error'
+  /^\s*(?:[A-Za-z]*Error|error)\s*[:(]/
+];
+var TEST_SUMMARY_RES = [
+  /^(Tests|Test Suites|Snapshots|Time|Duration):/,
+  /\d+\s+pass(?:ed|ing)\b/,
+  /\d+\s+fail(?:ed|ing)\b/,
+  /^test result:/,
+  /^Ran all test suites/,
+  /^=+ .* =+$/,
+  // node:test spec ('ℹ pass 118') and tap ('# pass 118') summary counters
+  /^(?:ℹ|#) (?:tests|suites|pass|fail|cancelled|skipped|todo|duration_ms) \d+\s*$/
+];
+function filterTestLog(content, style = "plain") {
+  const lines = content.split("\n");
+  const isFail = (l) => TEST_FAIL_RES.some((re) => re.test(l));
+  const isSummary = (l) => TEST_SUMMARY_RES.some((re) => re.test(l));
+  const isPass = (l) => TEST_PASS_RES.some((re) => re.test(l));
+  if (!lines.some(isFail) && !lines.some(isSummary)) return { content };
+  const out = [];
+  const omittedLines = [];
+  let markerIdx = -1;
+  for (const line of lines) {
+    if (isPass(line) && !isFail(line) && !isSummary(line)) {
+      if (markerIdx < 0) markerIdx = out.length;
+      omittedLines.push(line);
+    } else {
+      out.push(line);
+    }
+  }
+  if (omittedLines.length === 0) return { content };
+  out.splice(markerIdx, 0, logMarker("passing-test", omittedLines, style));
+  return tierResult(content, out.join("\n"), "log-filter");
+}
+var BUILD_ERROR_RES = [
+  /error\[E\d+\]/,
+  /^\s*(error|warning)(\s+[A-Z]+\d+)?:/i,
+  /\b(error|warning)\s+TS\d+:/,
+  /:\d+(?::\d+)?:\s*(?:fatal\s+)?(?:error|warning)\b/,
+  /npm ERR!/,
+  /^\s*(Error|TypeError|SyntaxError|ReferenceError|RangeError)\b/
+];
+var BUILD_STATUS_RES = [
+  /^\s*error: aborting/,
+  /^\s*error: could not compile/,
+  /Found \d+ errors?/,
+  /\d+ errors? generated/,
+  /^make: \*\*\*/,
+  /^Build (?:FAILED|failed|succeeded)/,
+  /^\s*Finished\b/,
+  /[✖✗] \d+ problems?/,
+  /exited with code \d+/
+];
+function filterBuildLog(content, style = "plain") {
+  const lines = content.split("\n");
+  const isError = (l) => BUILD_ERROR_RES.some((re) => re.test(l));
+  const isStatus = (l) => BUILD_STATUS_RES.some((re) => re.test(l));
+  if (!lines.some(isError) && !lines.some(isStatus)) return { content };
+  const out = [];
+  const omittedLines = [];
+  let markerIdx = -1;
+  let inErrorBlock = false;
+  for (const line of lines) {
+    let keep;
+    if (isError(line)) {
+      inErrorBlock = true;
+      keep = true;
+    } else if (isStatus(line)) {
+      inErrorBlock = false;
+      keep = true;
+    } else if (inErrorBlock) {
+      if (line.trim() === "") {
+        inErrorBlock = false;
+        keep = false;
+      } else {
+        keep = true;
+      }
+    } else {
+      keep = false;
+    }
+    if (keep) {
+      out.push(line);
+    } else {
+      if (markerIdx < 0) markerIdx = out.length;
+      omittedLines.push(line);
+    }
+  }
+  if (omittedLines.length === 0) return { content };
+  out.splice(markerIdx, 0, logMarker("build-log", omittedLines, style));
+  return tierResult(content, out.join("\n"), "log-filter");
+}
+
+// src/engine/policy.ts
+function policyFor(mode) {
+  switch (mode) {
+    case "full":
+      return {
+        structural: false,
+        codeAware: false,
+        logAware: false,
+        // 'plain' everywhere for now: the marker-style experiment (bench
+        // hookArgs --marker-style) varies this per arm and picks the winner.
+        markerStyle: "plain",
+        touch: Infinity,
+        truncateBudget: Infinity,
+        commentStrip: Infinity,
+        skeleton: Infinity,
+        logFilter: Infinity
+      };
+    // PLAN.md: optimized = tier 1 + comment-strip; lossy tier-3 log filtering
+    // is reserved for slim.
+    case "optimized":
+      return {
+        structural: true,
+        codeAware: true,
+        logAware: false,
+        markerStyle: "plain",
+        touch: 600,
+        truncateBudget: 5e3,
+        commentStrip: 2e3,
+        skeleton: Infinity,
+        logFilter: Infinity
+      };
+    case "slim":
+      return {
+        structural: true,
+        codeAware: true,
+        logAware: true,
+        markerStyle: "plain",
+        touch: 300,
+        // measured (bench-20260610-114234/-123102): a 2,500 budget pushed the
+        // model into offset/limit pagination — targeted reads pass through, so
+        // recovery re-reads nullified all savings (worst cell exceeded the
+        // uncompressed baseline). 5,000 stays under the recovery trigger.
+        truncateBudget: 5e3,
+        commentStrip: 1e3,
+        skeleton: 6e3,
+        logFilter: 800
+      };
+  }
+}
+
+// src/engine/index.ts
+function compress(content, meta, policy, estimate) {
+  const estTokensIn = estimate(content);
+  const bytesIn = utf8Bytes(content);
+  const passthrough = meta.mode === "full" || meta.targeted === true || content.includes(OMISSION_MARKER) || estTokensIn < policy.touch;
+  if (passthrough) {
+    return {
+      content,
+      stats: {
+        bytesIn,
+        bytesOut: bytesIn,
+        estTokensIn,
+        estTokensOut: estTokensIn,
+        kind: detectKind(content, meta.filePath),
+        transforms: []
+      }
+    };
+  }
+  let current = content;
+  const transforms = [];
+  const apply = (result) => {
+    current = result.content;
+    if (result.transform !== void 0) transforms.push(result.transform);
+  };
+  const decide = (text) => estimate(
+    text.includes(OMISSION_MARKER) ? text.split("\n").filter((line) => !line.includes(OMISSION_MARKER)).join("\n") : text
+  );
+  if (policy.structural) {
+    apply(stripAnsi(current));
+    apply(collapseBlankRuns(current));
+    apply(dedupeLines(current));
+  }
+  const kind = detectKind(current, meta.filePath);
+  if (policy.codeAware && kind === "code") {
+    const lang = langFromPath(meta.filePath);
+    if (decide(current) > policy.skeleton) {
+      apply(skeleton(current, lang, meta, estimate, policy.markerStyle));
+    } else if (decide(current) > policy.commentStrip) {
+      apply(stripComments(current, lang, policy.markerStyle));
+    }
+  }
+  if (policy.logAware && decide(current) > policy.logFilter) {
+    if (kind === "test-log") apply(filterTestLog(current, policy.markerStyle));
+    else if (kind === "build-log") apply(filterBuildLog(current, policy.markerStyle));
+  }
+  if (decide(current) > policy.truncateBudget) {
+    const positionsAreFileLines = transforms.every((t) => t.id === "strip-ansi");
+    apply(truncateHeadTail(current, meta, policy, decide, positionsAreFileLines));
+  }
+  return {
+    content: current,
+    stats: {
+      bytesIn,
+      bytesOut: utf8Bytes(current),
+      estTokensIn,
+      estTokensOut: estimate(current),
+      kind,
+      transforms
+    }
+  };
+}
+function utf8Bytes(text) {
+  return new TextEncoder().encode(text).length;
+}
+
+// src/tokens/estimate.ts
+var cheapEstimator = (text) => Math.ceil(text.length / 3.5);
+
+// src/ledger/write.ts
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { appendFile, mkdir } from "node:fs/promises";
+function resolveLedgerDir() {
+  return process.env["COMPRESSOR_LEDGER_DIR"] ?? path.join(os.homedir(), ".compressor", "ledger");
+}
+function monthOf(ts) {
+  const month = ts.slice(0, 7);
+  return /^\d{4}-\d{2}$/.test(month) ? month : "unknown";
+}
+var mkdirCache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Set();
+async function appendLedger(event) {
+  if (process.env["COMPRESSOR_NO_LEDGER"] === "1") {
+    return;
+  }
+  const task = (async () => {
+    try {
+      const dir = resolveLedgerDir();
+      let made = mkdirCache.get(dir);
+      if (made === void 0) {
+        made = mkdir(dir, { recursive: true }).then(
+          () => void 0,
+          () => void 0
+        );
+        mkdirCache.set(dir, made);
+      }
+      await made;
+      const file = path.join(dir, `${monthOf(event.ts)}.jsonl`);
+      await appendFile(file, `${JSON.stringify(event)}
+`, "utf8");
+    } catch {
+    }
+  })();
+  pending.add(task);
+  void task.finally(() => pending.delete(task));
+  return task;
+}
+async function settleLedger() {
+  try {
+    await Promise.all([...pending]);
+  } catch {
+  }
+}
+
+// src/hook/core.ts
+var MIN_SAVED_CHARS = 200;
+var MIN_SAVED_RATIO = 0.1;
+function lengthSansMarkers(text) {
+  if (!text.includes(OMISSION_MARKER)) {
+    return text.length;
+  }
+  return text.split("\n").filter((line) => !line.includes(OMISSION_MARKER)).join("\n").length;
+}
+function compressCall(call, mode, markerStyle) {
+  try {
+    const meta = { tool: call.toolKind, mode, targeted: call.targeted };
+    if (call.filePath !== void 0) {
+      meta.filePath = call.filePath;
+    }
+    const base = policyFor(mode);
+    const policy = markerStyle === void 0 ? base : { ...base, markerStyle };
+    const result = compress(call.text, meta, policy, cheapEstimator);
+    const saved = call.text.length - lengthSansMarkers(result.content);
+    if (saved < MIN_SAVED_CHARS || saved < call.text.length * MIN_SAVED_RATIO) {
+      return { text: call.text, worthwhile: false };
+    }
+    return { text: result.content, worthwhile: true, stats: result.stats };
+  } catch {
+    return { text: call.text, worthwhile: false };
+  }
+}
+function recordCompression(agent, call, compressed, mode) {
+  try {
+    if (!compressed.worthwhile) {
+      return;
+    }
+    void appendLedger({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent,
+      tool: call.toolKind,
+      mode,
+      charsIn: call.text.length,
+      charsOut: compressed.text.length,
+      estTokensIn: compressed.stats?.estTokensIn ?? cheapEstimator(call.text),
+      estTokensOut: compressed.stats?.estTokensOut ?? cheapEstimator(compressed.text),
+      transforms: compressed.stats?.transforms.map((t) => t.id) ?? []
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function longestStringLeaf(value, path2, best) {
+  if (typeof value === "string") {
+    return best === null || value.length > best.text.length ? { path: path2, text: value } : best;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce(
+      (acc, item, i) => longestStringLeaf(item, [...path2, i], acc),
+      best
+    );
+  }
+  if (isRecord(value)) {
+    return Object.entries(value).reduce(
+      (acc, [key, item]) => longestStringLeaf(item, [...path2, key], acc),
+      best
+    );
+  }
+  return best;
+}
+function pickLeaf(toolResponse, tool) {
+  if (typeof toolResponse === "string") {
+    return { path: [], text: toolResponse };
+  }
+  if (tool === "bash" && isRecord(toolResponse) && typeof toolResponse["stdout"] === "string") {
+    return { path: ["stdout"], text: toolResponse["stdout"] };
+  }
+  if (isRecord(toolResponse) || Array.isArray(toolResponse)) {
+    return longestStringLeaf(toolResponse, [], null);
+  }
+  return null;
+}
+function rebuildWithLeaf(toolResponse, path2, text) {
+  if (path2.length === 0) {
+    return text;
+  }
+  const clone = structuredClone(toolResponse);
+  let cursor = clone;
+  for (let i = 0; i < path2.length - 1; i += 1) {
+    const key = path2[i];
+    if (Array.isArray(cursor) && typeof key === "number") {
+      cursor = cursor[key];
+    } else if (isRecord(cursor) && typeof key === "string") {
+      cursor = cursor[key];
+    } else {
+      throw new Error("leaf path mismatch");
+    }
+  }
+  const last = path2[path2.length - 1];
+  if (Array.isArray(cursor) && typeof last === "number") {
+    cursor[last] = text;
+  } else if (isRecord(cursor) && typeof last === "string") {
+    cursor[last] = text;
+  } else {
+    throw new Error("leaf path mismatch");
+  }
+  return clone;
+}
+
+// src/hook/copilot.ts
+function toolKindFor(toolName) {
+  switch (toolName) {
+    case "view":
+      return "read";
+    case "bash":
+    case "powershell":
+      return "bash";
+    case "grep":
+    case "glob":
+      return "search";
+    default:
+      return "other";
+  }
+}
+var FILE_PATH_KEYS = ["path", "filePath", "file_path", "file"];
+function parseToolArgs(raw) {
+  if (isRecord(raw)) {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      if (isRecord(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return {};
+}
+var RANGE_KEYS = [
+  "offset",
+  "limit",
+  "startLine",
+  "endLine",
+  "start_line",
+  "end_line",
+  "range",
+  "viewRange",
+  "view_range"
+];
+function filePathFrom(args) {
+  for (const key of FILE_PATH_KEYS) {
+    const value = args[key];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isTargeted(args) {
+  return RANGE_KEYS.some((key) => args[key] != null);
+}
+function handleCopilotPostToolUse(payloadJson, mode, markerStyle) {
+  try {
+    if (mode === "full") {
+      return { output: null };
+    }
+    const payload = JSON.parse(payloadJson);
+    if (!isRecord(payload)) {
+      return { output: null };
+    }
+    const toolName = typeof payload["toolName"] === "string" ? payload["toolName"] : "";
+    const toolArgs = parseToolArgs(payload["toolArgs"]);
+    const tool = toolKindFor(toolName);
+    const toolResult = payload["toolResult"];
+    if (isRecord(toolResult) && toolResult["resultType"] !== void 0 && toolResult["resultType"] !== "success") {
+      return { output: null };
+    }
+    let text = null;
+    let genericLeaf = null;
+    if (isRecord(toolResult) && typeof toolResult["textResultForLlm"] === "string") {
+      text = toolResult["textResultForLlm"];
+    } else {
+      genericLeaf = pickLeaf(toolResult, tool);
+      if (genericLeaf === null) {
+        return { output: null };
+      }
+      text = genericLeaf.text;
+    }
+    const call = {
+      toolKind: tool,
+      targeted: tool === "read" && isTargeted(toolArgs),
+      text
+    };
+    const filePath = tool === "read" ? filePathFrom(toolArgs) : void 0;
+    if (filePath !== void 0) {
+      call.filePath = filePath;
+    }
+    const compressed = compressCall(call, mode, markerStyle);
+    if (!compressed.worthwhile) {
+      return { output: null };
+    }
+    recordCompression("copilot", call, compressed, mode);
+    const replacement = genericLeaf === null || genericLeaf.path.length === 0 ? compressed.text : JSON.stringify(rebuildWithLeaf(toolResult, genericLeaf.path, compressed.text));
+    return {
+      output: JSON.stringify({
+        modifiedResult: {
+          resultType: "success",
+          textResultForLlm: replacement
+        }
+      })
+    };
+  } catch {
+    return { output: null };
+  }
+}
+
+// src/hook/exit.ts
+import process2 from "node:process";
+var SETTLE_CAP_MS = 250;
+async function settleThenExit(output) {
+  try {
+    if (output !== null) {
+      await new Promise((resolve) => {
+        process2.stdout.write(output, () => resolve());
+      });
+    }
+  } catch {
+  }
+  let timedOut = true;
+  try {
+    let timer;
+    timedOut = await Promise.race([
+      settleLedger().then(() => false),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(true), SETTLE_CAP_MS);
+      })
+    ]);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  } catch {
+    timedOut = true;
+  }
+  if (timedOut) {
+    process2.kill(process2.pid, "SIGKILL");
+  }
+  process2.exit(0);
+}
+
+// src/copilot-hook-entry.ts
+function parseMode(argv) {
+  const idx = argv.indexOf("--mode");
+  const value = idx === -1 ? void 0 : argv[idx + 1];
+  return value === "full" || value === "optimized" || value === "slim" ? value : "optimized";
+}
+function parseMarkerStyle(argv) {
+  const idx = argv.indexOf("--marker-style");
+  const value = idx === -1 ? void 0 : argv[idx + 1];
+  return value === "plain" || value === "deterrent" || value === "informative" ? value : void 0;
+}
+async function main() {
+  const chunks = [];
+  for await (const chunk of process3.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const payload = Buffer.concat(chunks).toString("utf8");
+  return handleCopilotPostToolUse(
+    payload,
+    parseMode(process3.argv),
+    parseMarkerStyle(process3.argv)
+  ).output;
+}
+main().then(
+  (output) => {
+    settleThenExit(output).catch(() => process3.exit(0));
+  },
+  () => {
+    settleThenExit(null).catch(() => process3.exit(0));
+  }
+);