@wrongstack/tools 0.320.1 → 1.0.1

package/dist/{chunk-J74TMK4M.js → chunk-NJX2RXKJ.js}

@@ -1,15 +1,17 @@
 import {
   tryLegacyCodeOperation
-} from "./chunk-I7FBZOEP.js";
+} from "./chunk-T3SMFF5Q.js";
 import {
   spawnStream
-} from "./chunk-OYP27E3I.js";
+} from "./chunk-DRRY6SCM.js";
 import {
+  ensureInsideRoot,
   normalizeCommandOutput,
   safeResolveReal
 } from "./chunk-ZUFHAHTE.js";
 
 // src/format.ts
+import * as path from "node:path";
 import { ToolValidationError } from "@wrongstack/core/types";
 var formatTool = {
   name: "format",
@@ -43,18 +45,43 @@ var formatTool = {
       cwd: { type: "string", description: "Working directory (default: cwd)" }
     }
   },
+  writeTargets(input) {
+    if (input?.check) return [];
+    if (!input?.files) return [];
+    const rawFiles = Array.isArray(input.files) ? input.files : input.files.split(",");
+    return [
+      ...new Set(
+        rawFiles.filter((f) => typeof f === "string").map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean)
+      )
+    ];
+  },
   async execute(input, ctx, opts) {
     let final;
     const executeStream = formatTool.executeStream;
     if (!executeStream) throw new Error("formatTool: stream execution unavailable");
-    for await (const ev of executeStream(input, ctx, opts)) {
+    const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    for await (const ev of executeStream(input, ctx, { signal })) {
       if (ev.type === "final") final = ev.output;
     }
     if (!final) throw new Error("format: stream ended without final event");
     return final;
   },
   async *executeStream(input, ctx, opts) {
-    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    if (input.cwd !== void 0 && (typeof input.cwd !== "string" || !input.cwd.trim())) {
+      throw new ToolValidationError({
+        message: "format: cwd must be a non-empty string when provided.",
+        field: "cwd"
+      });
+    }
+    let cwd;
+    try {
+      cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    } catch (err) {
+      throw new ToolValidationError({
+        message: `format: ${err.message}`,
+        field: "cwd"
+      });
+    }
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
     signal.throwIfAborted();
     const VALID_FIXERS = /* @__PURE__ */ new Set(["biome", "prettier", "auto"]);
@@ -107,7 +134,21 @@ var formatTool = {
       text: `Running ${detected}\u2026`,
       data: { fixer: detected, check: !!input.check }
     };
-    const fileList = input.files ? (Array.isArray(input.files) ? input.files : input.files.split(",")).map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean) : [];
+    const fileList = input.files ? [
+      ...new Set(
+        (Array.isArray(input.files) ? input.files : input.files.split(",")).filter((f) => typeof f === "string").map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean)
+      )
+    ] : [];
+    for (const f of fileList) {
+      try {
+        ensureInsideRoot(path.resolve(cwd, f), ctx);
+      } catch (err) {
+        throw new ToolValidationError({
+          message: `format: file "${f}" ${err.message}`,
+          field: "files"
+        });
+      }
+    }
     let args;
     if (detected === "prettier") {
       args = [input.check ? "--check" : "--write"];
@@ -198,6 +239,8 @@ async function detectFixer(cwd) {
 }
 
 export {
-  formatTool
+  formatTool,
+  parseFormatterCounts,
+  detectFixer
 };
-//# sourceMappingURL=chunk-J74TMK4M.js.map
+//# sourceMappingURL=chunk-NJX2RXKJ.js.map

package/dist/chunk-NL2S2CXD.js

@@ -0,0 +1,171 @@
+// src/auto-proceed-loop-guard.ts
+function normalizeForRepetition(prompt) {
+  return prompt.replace(/\s+/g, " ").trim().toLowerCase();
+}
+var GROUNDED_NO_PROGRESS_STEER = [
+  "NOTE: The todo board has not changed since the previous automatic continuation \u2014 this exact instruction is being repeated.",
+  "Before anything else, bring the board up to date so the loop stays grounded:",
+  "- mark work that is actually finished as completed,",
+  "- split the current item into smaller concrete sub-items if it needs more than one turn,",
+  "- remove or reword items that no longer apply.",
+  "Then continue the work. If you are blocked, state exactly what is blocking you instead of repeating the same turn."
+].join("\n");
+function createContinuationAttemptTracker() {
+  const attempts = /* @__PURE__ */ new Map();
+  const skipped = /* @__PURE__ */ new Set();
+  return {
+    recordAttempt(todoId) {
+      const count = (attempts.get(todoId) ?? 0) + 1;
+      attempts.set(todoId, count);
+      return count;
+    },
+    getAttempts(todoId) {
+      return attempts.get(todoId) ?? 0;
+    },
+    markSkipped(todoId) {
+      skipped.add(todoId);
+    },
+    isSkipped(todoId) {
+      return skipped.has(todoId);
+    },
+    reset() {
+      attempts.clear();
+      skipped.clear();
+    },
+    snapshot() {
+      const result = {};
+      const allIds = /* @__PURE__ */ new Set([...attempts.keys(), ...skipped]);
+      for (const id of allIds) {
+        result[id] = { attempts: attempts.get(id) ?? 0, skipped: skipped.has(id) };
+      }
+      return result;
+    }
+  };
+}
+var ADVANCE_PREAMBLES = [
+  "Pivoting to the next open item \u2014 previous todo still pending after {attempts} attempt(s).",
+  "Shifting focus to a different task while the previous item ({label}) remains open after {attempts} attempt(s).",
+  "No board progress on the current item after {attempts} attempt(s). Continuing with the next todo.",
+  "The previous item is still unresolved after {attempts} try(ies). Moving on down the list.",
+  "Advancing to the next piece of work after {attempts} unproductive attempt(s) on the prior one.",
+  "Taking a different angle \u2014 the stalled item ({label}) stays open after {attempts} attempt(s). Pressing ahead.",
+  "The todo board shows no movement on the current task after {attempts} attempt(s). Switching gears.",
+  "No change on the board from the last {attempts} continuation(s). Proceeding to the next open item."
+];
+function generateAdvancementPrompt(stalledTodo, nextTodo, attemptCount, todos) {
+  const idx = Math.max(0, Math.min(attemptCount - 1, ADVANCE_PREAMBLES.length - 1));
+  const preamble = ADVANCE_PREAMBLES[idx].replace(
+    /\{attempts\}/g,
+    () => String(attemptCount)
+  ).replace(/\{label\}/g, () => stalledTodo.content.slice(0, 72));
+  if (!nextTodo) {
+    return [
+      preamble,
+      "",
+      "No more open items remain on the todo list. What has been accomplished and what should I do next?"
+    ].join("\n");
+  }
+  const itemLabel = nextTodo.status === "in_progress" && nextTodo.activeForm ? nextTodo.activeForm : nextTodo.content;
+  const done = todos.filter((t) => t.status === "completed").length;
+  const total = todos.length;
+  const lines = [preamble, "", `Proceed with: ${itemLabel}`];
+  if (total > 0) {
+    lines.push("", `Todo board (${done}/${total} done):`);
+    lines.push(
+      ...todos.slice(0, 20).map((t) => {
+        const mark = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+        const flat = t.content.replace(/\n|\r/g, " ");
+        return `  ${mark} ${flat}`;
+      })
+    );
+  }
+  lines.push(
+    "",
+    "If this item is already done, mark it complete and move to the next open todo. Keep the board honest as you work."
+  );
+  return lines.join("\n");
+}
+function matchTodoIdFromPrompt(todos, prompt) {
+  if (todos.length === 0 || !prompt) return null;
+  const lowerPrompt = prompt.toLowerCase();
+  const inProgress = todos.find((t) => t.status === "in_progress");
+  if (inProgress) {
+    const label = (inProgress.activeForm ?? inProgress.content).toLowerCase();
+    if (label.length > 5 && lowerPrompt.includes(label)) {
+      return { id: inProgress.id, content: inProgress.activeForm ?? inProgress.content };
+    }
+  }
+  for (const t of todos) {
+    if (t.status === "completed") continue;
+    if (inProgress && t.id === inProgress.id) continue;
+    const label = (t.activeForm ?? t.content).toLowerCase();
+    if (label.length > 5 && lowerPrompt.includes(label)) {
+      return { id: t.id, content: t.activeForm ?? t.content };
+    }
+  }
+  const firstOpen = todos.find((t) => t.status !== "completed");
+  return firstOpen ? { id: firstOpen.id, content: firstOpen.activeForm ?? firstOpen.content } : null;
+}
+var MAX_ADVANCEMENT_ATTEMPTS = 9;
+function createAutoProceedLoopGuard(options = {}) {
+  const safeIntegerOption = (value, fallback) => {
+    if (value === void 0) return fallback;
+    if (!Number.isFinite(value)) return fallback;
+    return Math.floor(value);
+  };
+  const repeatThreshold = Math.max(2, safeIntegerOption(options.repeatThreshold, 2));
+  const windowSize = Math.max(repeatThreshold, safeIntegerOption(options.windowSize, 3));
+  let buffer = [];
+  let steeredFor = null;
+  function record(prompt) {
+    const normalized = normalizeForRepetition(prompt);
+    buffer.push(normalized);
+    if (buffer.length > windowSize) {
+      buffer = buffer.slice(buffer.length - windowSize);
+    }
+    let runLength = 0;
+    for (let i = buffer.length - 1; i >= 0; i--) {
+      if (buffer[i] === normalized) runLength++;
+      else break;
+    }
+    return {
+      normalized,
+      runLength,
+      shouldHalt: runLength >= repeatThreshold
+    };
+  }
+  function recordGrounded(prompt) {
+    const signal = record(prompt);
+    if (!signal.shouldHalt) {
+      steeredFor = null;
+      return { ...signal, shouldHalt: false, action: "feed" };
+    }
+    if (steeredFor === signal.normalized) {
+      return { ...signal, action: "halt" };
+    }
+    steeredFor = signal.normalized;
+    return { ...signal, shouldHalt: false, action: "steer" };
+  }
+  function reset() {
+    buffer = [];
+    steeredFor = null;
+  }
+  function history() {
+    return buffer.slice();
+  }
+  function size() {
+    return buffer.length;
+  }
+  return { record, recordGrounded, reset, history, size };
+}
+
+export {
+  normalizeForRepetition,
+  GROUNDED_NO_PROGRESS_STEER,
+  createContinuationAttemptTracker,
+  generateAdvancementPrompt,
+  matchTodoIdFromPrompt,
+  MAX_ADVANCEMENT_ATTEMPTS,
+  createAutoProceedLoopGuard
+};
+//# sourceMappingURL=chunk-NL2S2CXD.js.map

package/dist/{chunk-WAQASTXB.js → chunk-O6BY43ZB.js}

@@ -1,9 +1,9 @@
 import {
   tryLegacyPackageOperation
-} from "./chunk-I7FBZOEP.js";
+} from "./chunk-T3SMFF5Q.js";
 import {
   spawnStream
-} from "./chunk-OYP27E3I.js";
+} from "./chunk-DRRY6SCM.js";
 import {
   detectPackageManager,
   normalizeCommandOutput,
@@ -66,16 +66,37 @@ var installTool = {
     let final;
     const executeStream = installTool.executeStream;
     if (!executeStream) throw new Error("installTool: stream execution unavailable");
-    for await (const ev of executeStream(input, ctx, opts)) {
+    const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    for await (const ev of executeStream(input, ctx, { signal })) {
       if (ev.type === "final") final = ev.output;
     }
     if (!final) throw new Error("install: stream ended without final event");
     return final;
   },
   async *executeStream(input, ctx, opts) {
-    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    if (input.cwd !== void 0 && (typeof input.cwd !== "string" || !input.cwd.trim())) {
+      throw new ToolValidationError({
+        message: "install: cwd must be a non-empty string when provided.",
+        field: "cwd"
+      });
+    }
+    let cwd;
+    try {
+      cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    } catch (err) {
+      throw new ToolValidationError({
+        message: `install: ${err.message}`,
+        field: "cwd"
+      });
+    }
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
     signal.throwIfAborted();
+    if (input.packages !== void 0 && typeof input.packages !== "string" && !Array.isArray(input.packages)) {
+      throw new ToolValidationError({
+        message: "install: packages must be a string or array of strings",
+        field: "packages"
+      });
+    }
     const VALID_SAVES = /* @__PURE__ */ new Set(["dependency", "dev", "optional"]);
     if (input.save !== void 0 && !VALID_SAVES.has(input.save)) {
       throw new ToolValidationError({
@@ -84,7 +105,7 @@ var installTool = {
       });
     }
     if (!input.global) {
-      const rawList2 = input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).map((p) => p.trim()).filter(Boolean) : [];
+      const rawList2 = input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).filter((p) => typeof p === "string").map((p) => p.trim()).filter(Boolean) : [];
       const pkgList2 = Array.from(new Set(rawList2));
       const bridge = await tryLegacyPackageOperation(
         "package-install",
@@ -102,7 +123,7 @@ var installTool = {
           type: "final",
           output: {
             exit_code: run?.exitCode ?? 0,
-            packages: [],
+            packages: pkgList2,
             output: normalizeCommandOutput(
               run?.output || outcome.manifestsChanged.join(", ") || "ok"
             ),
@@ -117,7 +138,7 @@ var installTool = {
     yield { type: "log", text: `Resolving with ${pkgManager}\u2026`, data: { phase: "resolve" } };
     const globalFlag = input.global ? ["-g"] : [];
     const ignoreScripts = input.lifecycleScripts !== true;
-    const rawList = input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).map((p) => p.trim()).filter(Boolean) : [];
+    const rawList = input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).filter((p) => typeof p === "string").map((p) => p.trim()).filter(Boolean) : [];
     const pkgList = Array.from(new Set(rawList));
     const PKG_NAME_RE = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+(?:@[a-z0-9^~><=*.+-]+)?$/i;
     for (const pkg of pkgList) {
@@ -232,4 +253,4 @@ function resolveManifestPath(cwd, pkgManager) {
 export {
   installTool
 };
-//# sourceMappingURL=chunk-WAQASTXB.js.map
+//# sourceMappingURL=chunk-O6BY43ZB.js.map

package/dist/{chunk-QGF2C7TF.js → chunk-PVCB7RUZ.js}

@@ -1,6 +1,6 @@
 import {
   getProcessRegistry
-} from "./chunk-ESLPBT5A.js";
+} from "./chunk-HDYUBRMF.js";
 
 // src/process-registry-persistent.ts
 import * as fs from "node:fs/promises";
@@ -519,4 +519,4 @@ export {
   getPersistentProcessRegistry,
   resetPersistentProcessRegistry
 };
-//# sourceMappingURL=chunk-QGF2C7TF.js.map
+//# sourceMappingURL=chunk-PVCB7RUZ.js.map

package/dist/{chunk-YTKSNTT4.js → chunk-QA6IASYX.js}

@@ -1,9 +1,9 @@
 import {
   tryLegacyCodeOperation
-} from "./chunk-I7FBZOEP.js";
+} from "./chunk-T3SMFF5Q.js";
 import {
   spawnStream
-} from "./chunk-OYP27E3I.js";
+} from "./chunk-DRRY6SCM.js";
 import {
   normalizeCommandOutput,
   safeResolveReal
@@ -166,7 +166,7 @@ function buildArgs(runner, input) {
       if (input.verbose) args.push("--verbose");
       if (input.watch) args.push("--watch");
       if (input.coverage) args.push("--coverage");
-      if (input.grep) args.push("--testPathPattern", input.grep);
+      if (input.grep) args.push("--testNamePattern", input.grep);
       args.push("--testTimeout", String(timeout));
       break;
     case "mocha":
@@ -195,12 +195,12 @@ function parseResult(runner, result, duration) {
     if (failedMatch?.[1]) failed = Number.parseInt(failedMatch[1], 10);
     tests_run = passed + failed;
   } else if (runner === "jest") {
-    const suitesMatch = out.match(/Test Suites:\s+(\d+)\s+total/);
-    const passedMatch = out.match(/Tests:\s+(\d+)\s+passed/);
-    const failedMatch = out.match(/Tests:\s+(\d+)\s+failed/);
-    tests_run = Number.parseInt(suitesMatch?.[1] ?? "0", 10);
+    const totalMatch = out.match(/Tests:\s+(?:.*,\s+)?(\d+)\s+total/);
+    const passedMatch = out.match(/Tests:\s+.*?(\d+)\s+passed/);
+    const failedMatch = out.match(/Tests:\s+.*?(\d+)\s+failed/);
     passed = Number.parseInt(passedMatch?.[1] ?? "0", 10);
     failed = Number.parseInt(failedMatch?.[1] ?? "0", 10);
+    tests_run = totalMatch?.[1] ? Number.parseInt(totalMatch[1], 10) : passed + failed;
   } else if (runner === "mocha") {
     const passedMatch = out.match(/(\d+)\s+passing/);
     const failedMatch = out.match(/(\d+)\s+failing/);
@@ -231,4 +231,4 @@ ${result.stderr}` : result.stdout || result.stderr || result.error || "";
 export {
   testTool
 };
-//# sourceMappingURL=chunk-YTKSNTT4.js.map
+//# sourceMappingURL=chunk-QA6IASYX.js.map

package/dist/{chunk-VPALDFYM.js → chunk-RV7BVTDG.js}

@@ -422,4 +422,4 @@ export {
   discoverE2EProjects,
   e2ePlanTool
 };
-//# sourceMappingURL=chunk-VPALDFYM.js.map
+//# sourceMappingURL=chunk-RV7BVTDG.js.map