@wrongstack/tools 0.296.4 → 0.298.0

package/dist/lint.js

@@ -78,11 +78,12 @@ function createOutputSpool(opts) {
   return {
     write(text) {
       if (finalized || !text) return;
-      totalBytes += Buffer.byteLength(text, "utf8");
+      const textBytes = Buffer.byteLength(text, "utf8");
+      totalBytes += textBytes;
       if (!stream && !failed) {
-        if (headBytes + text.length <= threshold) {
+        if (headBytes + textBytes <= threshold) {
           head += text;
-          headBytes += text.length;
+          headBytes += textBytes;
           return;
         }
         head += text;
@@ -92,7 +93,7 @@ function createOutputSpool(opts) {
       }
       if (stream) {
         if (stream.writableLength > SPOOL_WRITE_HWM_BYTES) {
-          droppedBytes += Buffer.byteLength(text, "utf8");
+          droppedBytes += textBytes;
           return;
         }
         stream.write(text);
@@ -114,6 +115,52 @@ function createOutputSpool(opts) {
   };
 }
 
+// src/_win32-resolve.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
+    return cmd;
+  }
+  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
+  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
+  for (const dir of pathDirs) {
+    const base = path2.join(dir, cmd);
+    for (const ext of pathext) {
+      const full = `${base}${ext}`;
+      try {
+        fs.accessSync(full, fs.constants.X_OK);
+        return full;
+      } catch {
+      }
+    }
+  }
+  return cmd;
+}
+var WIN32_SHELL_META = /[&|<>"\r\n\0]/;
+function assertSafeWin32ShellArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_SHELL_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32ShellArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
 // src/process-registry.ts
 import { spawn } from "node:child_process";
 import * as os from "node:os";
@@ -445,6 +492,7 @@ var ProcessRegistryImpl = class {
   }
   /** Get all tracked processes. */
   list() {
+    this._pruneAllStale();
     return Array.from(this.processes.values());
   }
   /** Get processes filtered by name (e.g. 'bash', 'exec'). */
@@ -475,6 +523,7 @@ var ProcessRegistryImpl = class {
    * Combined stats for observability — used by /ps and the TUI status bar.
    */
   stats() {
+    this._pruneAllStale();
     return {
       activeCount: this.activeCount,
       backgroundCount: this.activeBackgroundCount,
@@ -714,6 +763,19 @@ var ProcessRegistryImpl = class {
       this.processes.delete(pid);
     }
   }
+  /**
+   * Remove every stale entry, not just one PID. `list()`/`stats()` — the
+   * surfaces the TUI status bar and `/ps` poll — must prune too: a child
+   * whose 'close' event never fires (e.g. Windows grandchildren holding stdio
+   * open) would otherwise linger in the registry until someone looks up its
+   * exact PID, and PID reuse meanwhile makes `get()`/`kill()` target the
+   * wrong process. RAM-leak audit 2026-07-31, MEDIUM.
+   */
+  _pruneAllStale() {
+    for (const [pid, entry] of this.processes) {
+      if (this._isStaleEntry(entry)) this.processes.delete(pid);
+    }
+  }
 };
 var _registry;
 function getProcessRegistry() {
@@ -723,60 +785,17 @@ function getProcessRegistry() {
   return _registry;
 }
 
-// src/_win32-resolve.ts
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-function resolveWin32Command(cmd) {
-  if (process.platform !== "win32") return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
-    return cmd;
-  }
-  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
-  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
-  for (const dir of pathDirs) {
-    const base = path2.join(dir, cmd);
-    for (const ext of pathext) {
-      const full = `${base}${ext}`;
-      try {
-        fs.accessSync(full, fs.constants.X_OK);
-        return full;
-      } catch {
-      }
-    }
-  }
-  return cmd;
-}
-var WIN32_SHELL_META = /[&|<>"\r\n\0]/;
-function assertSafeWin32ShellArgs(args) {
-  for (const arg of args) {
-    if (typeof arg === "string" && WIN32_SHELL_META.test(arg)) {
-      throw new Error(
-        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
-      );
-    }
-  }
-}
-function buildWin32CmdShimInvocation(command, args = []) {
-  assertSafeWin32ShellArgs([command, ...args]);
-  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
-  return {
-    command: process.env["COMSPEC"] ?? "cmd.exe",
-    args: ["/d", "/c", line],
-    windowsVerbatimArguments: true
-  };
-}
-function quoteWin32CmdArg(arg) {
-  return `"${arg}"`;
-}
-
 // src/_spawn-stream.ts
 var isWin = process.platform === "win32";
 async function* spawnStream(opts) {
   const max = opts.maxBytes ?? 2e5;
   const flushAt = opts.flushBytes ?? 4 * 1024;
   const maxQueue = opts.maxQueueSize ?? 500;
+  const maxQueueBytes = opts.maxQueueBytes ?? 1024 * 1024;
   let stdout = "";
   let stderr = "";
+  let stdoutRetainedBytes = 0;
+  let stderrRetainedBytes = 0;
   let pending = "";
   let error;
   const spool = createOutputSpool({ tool: opts.cmd, thresholdBytes: max });
@@ -818,6 +837,7 @@ async function* spawnStream(opts) {
     });
   }
   const queue = [];
+  let queuedBytes = 0;
   let waiter;
   let paused = false;
   const wake = () => {
@@ -828,7 +848,7 @@ async function* spawnStream(opts) {
     }
   };
   const resume = () => {
-    if (paused && queue.length < maxQueue) {
+    if (paused && queue.length <= Math.floor(maxQueue / 2) && queuedBytes <= Math.floor(maxQueueBytes / 2)) {
       paused = false;
       child.stdout?.resume();
       child.stderr?.resume();
@@ -838,11 +858,16 @@ async function* spawnStream(opts) {
     const s = c.toString();
     stdoutBytes += c.byteLength;
     emitProcessOutput({ pid, stream: "stdout", chunk: c });
-    if (stdout.length < max) stdout += s;
+    if (stdoutRetainedBytes < max) {
+      const retained = utf8Prefix(s, max - stdoutRetainedBytes);
+      stdout += retained;
+      stdoutRetainedBytes += Buffer.byteLength(retained, "utf8");
+    }
     spool.write(s);
-    queue.push({ kind: "out", data: s });
+    queue.push({ kind: "out", data: s, bytes: c.byteLength });
+    queuedBytes += c.byteLength;
     wake();
-    if (!paused && queue.length >= maxQueue) {
+    if (!paused && (queue.length >= maxQueue || queuedBytes >= maxQueueBytes)) {
       paused = true;
       child.stdout?.pause();
       child.stderr?.pause();
@@ -852,11 +877,16 @@ async function* spawnStream(opts) {
     const s = c.toString();
     stderrBytes += c.byteLength;
     emitProcessOutput({ pid, stream: "stderr", chunk: c });
-    if (stderr.length < max) stderr += s;
+    if (stderrRetainedBytes < max) {
+      const retained = utf8Prefix(s, max - stderrRetainedBytes);
+      stderr += retained;
+      stderrRetainedBytes += Buffer.byteLength(retained, "utf8");
+    }
     spool.write(s);
-    queue.push({ kind: "err", data: s });
+    queue.push({ kind: "err", data: s, bytes: c.byteLength });
+    queuedBytes += c.byteLength;
     wake();
-    if (!paused && queue.length >= maxQueue) {
+    if (!paused && (queue.length >= maxQueue || queuedBytes >= maxQueueBytes)) {
       paused = true;
       child.stdout?.pause();
       child.stderr?.pause();
@@ -866,7 +896,9 @@ async function* spawnStream(opts) {
   child.stderr?.on("data", onErr);
   child.on("error", (e) => {
     error = e.message;
-    queue.push({ kind: "error", data: e.message });
+    const bytes = Buffer.byteLength(e.message, "utf8");
+    queue.push({ kind: "error", data: e.message, bytes });
+    queuedBytes += bytes;
     wake();
   });
   const completeTelemetry = (code, signal, timedOut = false) => {
@@ -887,7 +919,13 @@ async function* spawnStream(opts) {
     if (typeof pid === "number") registry.unregister(pid);
     const exitCode2 = code ?? (signal ? 1 : 0);
     completeTelemetry(exitCode2, signal ?? void 0);
-    queue.push({ kind: "close", data: "", code: exitCode2, ...signal ? { signal } : {} });
+    queue.push({
+      kind: "close",
+      data: "",
+      bytes: 0,
+      code: exitCode2,
+      ...signal ? { signal } : {}
+    });
     wake();
   });
   const onAbort = () => {
@@ -899,7 +937,7 @@ async function* spawnStream(opts) {
       } catch {
       }
     }
-    queue.push({ kind: "close", data: "", code: 124 });
+    queue.push({ kind: "close", data: "", bytes: 0, code: 124 });
     completeTelemetry(124, "SIGKILL", true);
     wake();
   };
@@ -917,6 +955,7 @@ async function* spawnStream(opts) {
         });
       }
       const chunk = queue.shift();
+      queuedBytes -= chunk.bytes;
       resume();
       if (chunk.kind === "close") {
         if (!spawnFailed) exitCode = chunk.code ?? 0;
@@ -943,7 +982,7 @@ async function* spawnStream(opts) {
       stdout: spooled ? stdout + spoolNote(spooled) : stdout,
       stderr,
       exitCode,
-      truncated: stdout.length >= max || stderr.length >= max,
+      truncated: stdoutBytes > stdoutRetainedBytes || stderrBytes > stderrRetainedBytes,
       error,
       spoolPath: spooled?.path,
       spoolBytes: spooled?.bytes
@@ -967,6 +1006,20 @@ async function* spawnStream(opts) {
     }
   }
 }
+function utf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  let end = low;
+  if (end > 0 && /[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+  return text.slice(0, end);
+}
 
 // src/_util.ts
 import * as path3 from "node:path";
@@ -2534,8 +2587,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, extraIgn
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename4, profiles, state) {
-  const lower = basename4.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename5, profiles, state) {
+  const lower = basename5.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2546,7 +2599,7 @@ function collectFileEvidence(directory, fullPath, basename4, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename4,
+        value: basename5,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -2966,10 +3019,11 @@ var MAX_ARGUMENTS = 128;
 var MAX_ARGUMENT_LENGTH = 4096;
 var PACKAGE_NAME_RE = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+(?:@[a-z0-9*+._~^<>=|-]+)?$/i;
 var COMPOSER_PACKAGE_RE = /^[a-z0-9_.-]+\/[a-z0-9_.-]+(?::[a-z0-9*+._~^<>=|-]+)?$/i;
-var GO_MODULE_RE = /^(?:[a-z0-9.-]+\.)+[a-z0-9.-]+\/[a-z0-9._~+/@-]+$/i;
+var GO_MODULE_RE = /^(?:[a-z0-9-]+\.)+[a-z0-9-]+\/[a-z0-9._~+/@-]+$/i;
 var PYTHON_PACKAGE_RE = /^[a-z0-9._-]+(?:\[[a-z0-9._,-]+\])?==[a-z0-9*+._!~-]+$/i;
 async function planLanguageOperation(options) {
   validateOperationOptions(options.operation, options.operationOptions?.packages);
+  validateFilterOption(options.operationOptions?.filter);
   const detection = await detectLanguageWorkspaces(options);
   const candidates = detection.workspaces.filter(
     (workspace) => workspace.capabilities.includes(options.operation)
@@ -3142,6 +3196,15 @@ function workspaceDepth(workspaceRoot, projectRoot) {
   const relative5 = path6.relative(path6.resolve(projectRoot), path6.resolve(workspaceRoot));
   return relative5 === "" ? 0 : relative5.split(path6.sep).length;
 }
+function validateFilterOption(filter) {
+  if (filter === void 0) return;
+  if (filter.startsWith("-") || filter.includes(" --")) {
+    throw new Error(`Invalid test filter (parsed as a runner option): "${filter}"`);
+  }
+  if (filter.length > MAX_ARGUMENT_LENGTH || /[\r\n\0]/.test(filter)) {
+    throw new Error("Invalid test filter (oversized or contains a control character)");
+  }
+}
 function validateOperationOptions(operation, packages) {
   if (!operation.startsWith("package-") || !packages) return;
   for (const value of packages) {

package/dist/next-steps.d.ts

@@ -46,6 +46,29 @@ export interface ParseNextStepsResult {
     /** The first item's text when it has auto="true"; otherwise empty. */
     autoTexts: string[];
 }
+/**
+ * Whether an LLM response's stop reason means the message is the FINAL one of
+ * a turn.
+ *
+ * The agent loop calls the provider once per iteration, so a multi-step turn
+ * emits several assistant messages. Only the last one — the response that
+ * stopped without asking for another tool — is the model's actual answer;
+ * everything before it is mid-turn prose the model wrote on its way to a tool
+ * call. A `<nextsteps>` block in mid-turn text is noise: surfacing it would
+ * offer the user suggestions while the work is still in flight, and would let
+ * `/next` and auto-submit pick up a suggestion the model has already moved on
+ * from.
+ *
+ * Every surface that renders suggestions gates on this so the three of them
+ * cannot disagree about where a turn ends. Callers still strip the block from
+ * the message body regardless — the raw XML must never reach the user.
+ *
+ * `tool_call` is the spelling some providers put on the WebUI wire (typed
+ * loosely as `stopReason: string`); the canonical `StopReason` union uses
+ * `tool_use`. An absent stop reason counts as final so legacy paths that never
+ * carried one keep their suggestions.
+ */
+export declare function isFinalTurnStopReason(stopReason: string | undefined): boolean;
 /**
  * Parse canonical "<nextsteps>" blocks from assistant output (or raw numbered lines).
  *

package/dist/next-steps.js

@@ -1,4 +1,7 @@
 // src/next-steps.ts
+function isFinalTurnStopReason(stopReason) {
+  return stopReason !== "tool_use" && stopReason !== "tool_call";
+}
 var NEXT_STEPS_TAG_RE = /<nextsteps\b[^>]*>\s*\n+/i;
 var ITEM_RE = /^(?:(\d+)[.)]\s*|[-*•]\s*)(.+?)(\s+auto="true")?$/;
 var MAX_STEPS = 6;
@@ -111,6 +114,7 @@ function stripNextStepsBlock(text) {
   return text.replace(/<next_?steps\b[^>]*>[\s\S]*?<\/next_?steps>/gi, "").replace(/<next_?steps\b[^>]*\/?>/gi, "").replace(/\n{3,}/g, "\n\n").trim();
 }
 export {
+  isFinalTurnStopReason,
   parseNextSteps,
   stripNextStepsBlock
 };