@wrongstack/core 0.24.0 → 0.31.1

package/dist/utils/index.d.ts

@@ -142,6 +142,21 @@ declare function createToolOutputSerializer(opts?: ToolOutputSerializerOptions):
 /**
  * Shared token estimation with JSON.stringify caching.
  * Avoids repeated stringification of tool input objects.
+ *
+ * ## Calibration
+ *
+ * `estimateRequestTokens` uses a fixed 3.5 chars/token heuristic — a
+ * conservative overestimate that prevents underestimation but reduces
+ * accuracy. After each API call, call `recordActualUsage()` with the
+ * real `usage.input` from the provider response. The module maintains a
+ * rolling average of `actual / estimated` ratio (EWM, α=0.3) and
+ * applies it to subsequent calls via `estimateRequestTokensCalibrated`.
+ *
+ * Calibration is per-module (shared across all callers), which is
+ * sufficient: the chars/token ratio is a property of the tokenizer,
+ * not the model. Uncalibrated calls (before any samples, or when
+ * `recordActualUsage` is not called) fall back to the uncalibrated
+ * estimate so nothing breaks.
  */
 /**
  * Estimate tokens for a tool_use block input.
@@ -190,6 +205,47 @@ declare function estimateRequestTokens(messages: unknown, systemPrompt: unknown,
     description?: string;
     inputSchema: unknown;
 }[]): RequestTokenBreakdown;
+/**
+ * Record the actual API input token count after a provider call so
+ * `estimateRequestTokensCalibrated` can self-correct on subsequent calls.
+ *
+ * Prefer passing `estimatedInputTokens` explicitly (the calibrated pre-flight
+ * estimate from the middleware) — this avoids race conditions when other code
+ * also calls `estimateRequestTokens` between the pre-flight and this call
+ * (e.g. audit logging in agent.ts).
+ *
+ * When `estimatedInputTokens` is omitted, falls back to `_cal.prevEst`
+ * for backward compatibility with callers that don't have the pre-flight value.
+ */
+declare function recordActualUsage(actualInputTokens: number, estimatedInputTokens?: number): void;
+/**
+ * Returns the current calibration state. Exposed for debugging and
+ * tests — not needed by normal callers.
+ */
+declare function getCalibrationState(): {
+    ratio: number;
+    count: number;
+    calibrated: boolean;
+};
+/**
+ * Like `estimateRequestTokens` but applies the rolling calibration factor
+ * so context pressure readings converge on reality within a few iterations.
+ *
+ * Before any `recordActualUsage` samples are collected, returns the same
+ * result as `estimateRequestTokens` (ratio = 1.0, no distortion).
+ * After `MIN_SAMPLES_FOR_CALIBRATION` samples, applies the calibrated
+ * multiplier capped to the range [0.5, 1.5] as a sanity bound.
+ */
+declare function estimateRequestTokensCalibrated(messages: unknown, systemPrompt: unknown, tools: {
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+}[]): RequestTokenBreakdown;
+/**
+ * Resets calibration state. Primarily for tests that run in the same
+ * process and need a clean slate between suites.
+ */
+declare function resetCalibration(): void;
 
 interface MessageRepairReport {
     changed: boolean;
@@ -254,6 +310,25 @@ interface CompileFail {
 }
 declare function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail;
 
+/**
+ * Glob pattern → concrete file path expansion.
+ *
+ * Supports: *, **, ?, [...]
+ * Does NOT support brace expansion {a,b}.
+ *
+ * Returns the input as-is if it contains no glob metacharacters.
+ * On Windows, both / and \ are accepted as path separators.
+ */
+/**
+ * Resolve `pattern` to the set of concrete file paths it matches.
+ * Literal paths (no glob chars) are returned as-is.
+ *
+ * @example
+ * await expandGlob('src/**\/*.ts')  // → ['src/a.ts', 'src/b/c.ts', ...]
+ * await expandGlob('foo.txt')       // → ['foo.txt']
+ */
+declare function expandGlob(pattern: string): Promise<string[]>;
+
 /**
  * Attempt to close an incomplete JSON object string by auto-closing braces
  * and completing any unclosed double-quoted string values.
@@ -296,4 +371,4 @@ declare function completePartialObject(s: string): string;
  */
 declare function mergeModelsPayload(base: ModelsDevPayload, overlay: ModelsDevPayload): ModelsDevPayload;
 
-export { type AtomicWriteOptions, type BuildChildEnvOptions, type CompileFail, type CompileResult, type MessageRepairReport, type MessageRepairResult, type NewlineStyle, type RequestTokenBreakdown, type SafeParseResult, type ToolOutputSerializerOptions, type UnifiedDiffOptions, type ValidationError, type ValidationResult, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, formatTodosList, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, repairToolUseAdjacency, safeParse, safeStringify, sanitizeJsonString, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema };
+export { type AtomicWriteOptions, type BuildChildEnvOptions, type CompileFail, type CompileResult, type MessageRepairReport, type MessageRepairResult, type NewlineStyle, type RequestTokenBreakdown, type SafeParseResult, type ToolOutputSerializerOptions, type UnifiedDiffOptions, type ValidationError, type ValidationResult, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, recordActualUsage, repairToolUseAdjacency, resetCalibration, safeParse, safeStringify, sanitizeJsonString, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema };

package/dist/utils/index.js

@@ -1,6 +1,7 @@
 import { randomBytes, createHash } from 'crypto';
 import * as fs from 'fs/promises';
 import * as path2 from 'path';
+import { isAbsolute, resolve } from 'path';
 import * as os from 'os';
 
 // src/utils/atomic-write.ts
@@ -25,8 +26,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat2 = await fs.stat(targetPath);
-      mode = stat2.mode & 511;
+      const stat3 = await fs.stat(targetPath);
+      mode = stat3.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -63,7 +64,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+      await new Promise((resolve3) => setTimeout(resolve3, delays[i]));
     }
   }
   throw lastErr;
@@ -657,6 +658,17 @@ function createToolOutputSerializer(opts = {}) {
 
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var _cal = {
+  ratio: 1,
+  // current calibration multiplier (actual / estimated)
+  count: 0,
+  // number of samples recorded
+  prevEst: 0,
+  // estimated tokens from the most recent estimateRequestTokens call
+  /** EWM α — higher = faster adaptation, more volatile */
+  alpha: 0.3
+};
+var MIN_SAMPLES_FOR_CALIBRATION = 3;
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
 var ESTIMATE_CACHE_MAX_SIZE = 1e4;
 function getCachedEstimate(key, compute) {
@@ -729,13 +741,53 @@ function estimateRequestTokens(messages, systemPrompt, tools) {
   for (const t of tools) {
     toolsTokens += estimateToolDefTokens(t);
   }
+  const total = messagesTokens + systemTokens + toolsTokens;
+  _cal.prevEst = total;
   return {
     messages: messagesTokens,
     systemPrompt: systemTokens,
     tools: toolsTokens,
-    total: messagesTokens + systemTokens + toolsTokens
+    total
+  };
+}
+function recordActualUsage(actualInputTokens, estimatedInputTokens) {
+  if (actualInputTokens <= 0) return;
+  const est = estimatedInputTokens ?? _cal.prevEst;
+  if (est <= 0) return;
+  const sampleRatio = actualInputTokens / est;
+  if (_cal.count === 0) {
+    _cal.ratio = sampleRatio;
+  } else {
+    _cal.ratio = _cal.alpha * sampleRatio + (1 - _cal.alpha) * _cal.ratio;
+  }
+  _cal.ratio = Math.min(1.5, Math.max(0.5, _cal.ratio));
+  _cal.count++;
+}
+function getCalibrationState() {
+  return {
+    ratio: _cal.ratio,
+    count: _cal.count,
+    calibrated: _cal.count >= MIN_SAMPLES_FOR_CALIBRATION
   };
 }
+function estimateRequestTokensCalibrated(messages, systemPrompt, tools) {
+  const result = estimateRequestTokens(messages, systemPrompt, tools);
+  if (_cal.count >= MIN_SAMPLES_FOR_CALIBRATION) {
+    const safeRatio = Math.min(1.5, Math.max(0.5, _cal.ratio));
+    return {
+      messages: Math.round(result.messages * safeRatio),
+      systemPrompt: Math.round(result.systemPrompt * safeRatio),
+      tools: Math.round(result.tools * safeRatio),
+      total: Math.round(result.total * safeRatio)
+    };
+  }
+  return result;
+}
+function resetCalibration() {
+  _cal.ratio = 1;
+  _cal.count = 0;
+  _cal.prevEst = 0;
+}
 
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
@@ -958,6 +1010,120 @@ function compileUserRegex(pattern, flags) {
     };
   }
 }
+var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
+var IS_WINDOWS = process.platform === "win32";
+var SEP = IS_WINDOWS ? "\\" : "/";
+function isGlob(p) {
+  for (const c of p) {
+    if (GLOB_CHARS.has(c)) return true;
+  }
+  return false;
+}
+function globToRegex(pat) {
+  let i = 0, re = "^";
+  while (i < pat.length) {
+    const c = pat[i];
+    if (c === "*") {
+      if (pat[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        if (pat[i] === "/") i++;
+      } else {
+        re += "[^/\\\\]*";
+        i++;
+      }
+    } else if (c === "?") {
+      re += "[^/\\\\]";
+      i++;
+    } else if (c === "[") {
+      let cls = "[";
+      i++;
+      if (pat[i] === "!" || pat[i] === "^") {
+        cls += "^";
+        i++;
+      }
+      while (i < pat.length && pat[i] !== "]") {
+        const ch = pat[i] ?? "";
+        if (ch === "\\") cls += "\\\\";
+        else if (ch === "]" || ch === "^") cls += `\\${ch}`;
+        else cls += ch;
+        i++;
+      }
+      cls += "]";
+      re += cls;
+      i++;
+    } else {
+      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
+      i++;
+    }
+  }
+  return new RegExp(re + "$");
+}
+function baseDir(pat) {
+  let i = pat.length - 1;
+  while (i >= 0 && !GLOB_CHARS.has(pat[i]) && pat[i] !== SEP && pat[i] !== "/") i--;
+  const cut = i >= 0 ? pat.lastIndexOf(SEP, i) : pat.lastIndexOf("/", i);
+  return cut < 0 ? "." : pat.slice(0, cut);
+}
+async function expandGlob(pattern) {
+  if (!isGlob(pattern)) return [pattern];
+  const results = /* @__PURE__ */ new Set();
+  const abs = isAbsolute(pattern);
+  const base = abs ? baseDir(pattern) : baseDir(pattern);
+  const relPat = base === "." ? pattern : pattern.slice(base.length + 1);
+  async function walk2(dir, pat) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      return;
+    }
+    const firstGlob = pat.search(/[*?[\[]/);
+    if (firstGlob < 0) {
+      const re = globToRegex(pat);
+      for (const e of entries) {
+        if (re.test(e)) {
+          const full = `${dir}${SEP}${e}`;
+          results.add(abs ? resolve(full) : full);
+        }
+      }
+      return;
+    }
+    const before = pat.slice(0, firstGlob);
+    const rest = pat.slice(firstGlob);
+    if (before.endsWith("**")) {
+      await walk2(dir, rest);
+      for (const e of entries) {
+        const full = `${dir}${SEP}${e}`;
+        try {
+          const stat3 = await fs.stat(full);
+          if (stat3.isDirectory()) await walk2(full, rest);
+        } catch {
+        }
+      }
+    } else if (before === "") {
+      const re = globToRegex(rest);
+      for (const e of entries) {
+        if (re.test(e)) {
+          const full = `${dir}${SEP}${e}`;
+          results.add(abs ? resolve(full) : full);
+        }
+      }
+    } else {
+      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
+      if (entries.includes(seg)) {
+        const full = `${dir}${SEP}${seg}`;
+        try {
+          const stat3 = await fs.stat(full);
+          if (stat3.isDirectory()) await walk2(full, rest);
+        } catch {
+        }
+      }
+    }
+  }
+  await walk2(base === "." ? "." : base, relPat);
+  return [...results];
+}
 
 // src/utils/json-repair.ts
 function completePartialObject(s) {
@@ -1111,6 +1277,6 @@ function stripUndefined(obj) {
   return out;
 }
 
-export { atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, formatTodosList, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, projectHash, repairToolUseAdjacency, resolveWstackPaths, safeParse, safeStringify, sanitizeJsonString, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema };
+export { atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, projectHash, recordActualUsage, repairToolUseAdjacency, resetCalibration, resolveWstackPaths, safeParse, safeStringify, sanitizeJsonString, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map