@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-BSLVR56S.js

@@ -0,0 +1,199 @@
+import {
+  tryLegacyCodeOperation
+} from "./chunk-PQKK5JH7.js";
+import {
+  spawnStream
+} from "./chunk-22B7GE5T.js";
+import {
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/test.ts
+import * as path from "node:path";
+var testTool = {
+  name: "test",
+  category: "Code Quality",
+  description: "Execute the project's test suite. This is one of the most critical tools for validating that your changes are correct.",
+  usageHint: "ESSENTIAL BEFORE CONSIDERING WORK DONE:\n\n- Use `files` or `grep` to run only relevant tests during development.\n- `coverage: true` is useful when working on critical paths.\nRun tests frequently. A clean test run is usually required before the task can be considered complete.",
+  permission: "confirm",
+  mutating: false,
+  icon: "test",
+  timeoutMs: 12e4,
+  capabilities: ["shell.restricted"],
+  inputSchema: {
+    type: "object",
+    properties: {
+      files: {
+        type: "string",
+        description: 'Test files: single path, comma-separated list, or glob (e.g. "**/*.test.ts")'
+      },
+      runner: {
+        type: "string",
+        enum: ["vitest", "jest", "mocha", "auto"],
+        description: "Test runner (default: auto-detect)"
+      },
+      watch: { type: "boolean", description: "Run in watch mode (default: false)" },
+      coverage: { type: "boolean", description: "Generate coverage report (default: false)" },
+      cwd: { type: "string", description: "Working directory (default: cwd)" },
+      grep: { type: "string", description: "Filter tests by name pattern (default: none)" },
+      timeout: { type: "integer", description: "Test timeout in ms (default: 30000)" },
+      verbose: {
+        type: "boolean",
+        description: "Per-test verbose reporter output (default: false \u2014 the summary reporter is used; full output is always saved to a log file referenced in the result)"
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = testTool.executeStream;
+    if (!executeStream) throw new Error("testTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("test: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    const runner = input.runner ?? "auto";
+    if (runner === "auto") {
+      const bridge = await tryLegacyCodeOperation("test", {
+        cwd,
+        projectRoot: ctx.projectRoot,
+        signal: opts.signal
+      });
+      if (bridge?.run) {
+        const run = bridge.run;
+        yield {
+          type: "final",
+          output: {
+            runner: bridge.language,
+            exit_code: run.exitCode ?? 0,
+            tests_run: (run.summary.passed ?? 0) + (run.summary.failed ?? 0),
+            passed: run.summary.passed ?? 0,
+            failed: run.summary.failed ?? 0,
+            duration_ms: run.durationMs,
+            output: normalizeCommandOutput(run.output || run.error || ""),
+            truncated: run.truncated
+          }
+        };
+        return;
+      }
+    }
+    const detected = runner === "auto" ? await detectRunner(cwd) : runner;
+    if (!detected) {
+      yield {
+        type: "final",
+        output: {
+          runner: "none",
+          exit_code: 0,
+          tests_run: 0,
+          passed: 0,
+          failed: 0,
+          duration_ms: 0,
+          output: "No test runner found (vitest.config.ts, jest.config.js, .mocharc.json)",
+          truncated: false
+        }
+      };
+      return;
+    }
+    yield { type: "log", text: `Running ${detected}\u2026`, data: { runner: detected } };
+    const start = Date.now();
+    const args = buildArgs(detected, input);
+    const result = yield* spawnStream({
+      cmd: detected,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 2e5
+    });
+    const duration = Date.now() - start;
+    yield { type: "final", output: parseResult(detected, result, duration) };
+  }
+};
+async function detectRunner(cwd) {
+  const { stat } = await import("node:fs/promises");
+  const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
+  for (const f of candidates) {
+    try {
+      await stat(path.join(cwd, f));
+      if (f.includes("vitest")) return "vitest";
+      if (f.includes("jest")) return "jest";
+      if (f.includes("mocha")) return "mocha";
+    } catch {
+    }
+  }
+  return null;
+}
+function buildArgs(runner, input) {
+  const args = [];
+  const timeout = input.timeout ?? 3e4;
+  switch (runner) {
+    case "vitest":
+      args.push(input.watch ? "watch" : "run");
+      if (input.verbose) args.push("--reporter=verbose");
+      if (input.coverage) args.push("--coverage");
+      if (input.grep) args.push("--testNamePattern", input.grep);
+      args.push("--testTimeout", String(timeout));
+      break;
+    case "jest":
+      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);
+      args.push("--testTimeout", String(timeout));
+      break;
+    case "mocha":
+      args.push("--reporter", "spec");
+      if (input.grep) args.push("--grep", input.grep);
+      args.push("--timeout", String(timeout));
+      break;
+  }
+  if (input.files) {
+    const files = Array.isArray(input.files) ? input.files : input.files.split(",");
+    args.push("--", ...files.map((f) => f.trim()));
+  }
+  return args;
+}
+function parseResult(runner, result, duration) {
+  const out = result.stdout + result.stderr;
+  let tests_run = 0;
+  let passed = 0;
+  let failed = 0;
+  if (runner === "vitest") {
+    const passedMatch = out.match(/(\d+) passed/);
+    const failedMatch = out.match(/(\d+) failed/);
+    if (passedMatch?.[1]) passed = Number.parseInt(passedMatch[1], 10);
+    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);
+    passed = Number.parseInt(passedMatch?.[1] ?? "0", 10);
+    failed = Number.parseInt(failedMatch?.[1] ?? "0", 10);
+  }
+  return {
+    runner,
+    exit_code: result.exitCode,
+    tests_run,
+    passed,
+    failed,
+    duration_ms: duration,
+    // A passing run only needs the tail summary in chat history — counts are
+    // already parsed above and the FULL log is on disk (spool marker rides
+    // the stdout tail). Failures keep the standard command-output cap so
+    // the agent sees the failure details inline.
+    output: normalizeCommandOutput(result.stdout || result.error || "", {
+      maxBytes: result.exitCode === 0 ? 4096 : void 0
+    }),
+    truncated: result.truncated
+  };
+}
+
+export {
+  testTool
+};
+//# sourceMappingURL=chunk-BSLVR56S.js.map

package/dist/chunk-BTSFTGIL.js

@@ -0,0 +1,7 @@
+// src/_env.ts
+import { buildChildEnv } from "@wrongstack/core/utils";
+
+export {
+  buildChildEnv
+};
+//# sourceMappingURL=chunk-BTSFTGIL.js.map

package/dist/chunk-D33S4RQG.js

@@ -0,0 +1,222 @@
+// src/_util.ts
+import { createHash } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as Core from "@wrongstack/core/utils";
+function sha256hex(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function detectPackageManager(cwd, stopAt) {
+  let dir = path.resolve(cwd);
+  const stop = stopAt ? path.resolve(stopAt) : dir;
+  for (; ; ) {
+    const found = await detectPackageManagerInDir(dir);
+    if (found) return found;
+    if (dir === stop) break;
+    const parent = path.dirname(dir);
+    const relParent = path.relative(stop, parent);
+    if (parent === dir || relParent.startsWith("..") || path.isAbsolute(relParent)) break;
+    dir = parent;
+  }
+  return "npm";
+}
+async function detectPackageManagerInDir(dir) {
+  const fs = await import("node:fs/promises");
+  try {
+    const raw = await fs.readFile(path.join(dir, "package.json"), "utf8");
+    const declared = JSON.parse(raw).packageManager;
+    if (typeof declared === "string") {
+      const name = declared.split("@")[0] ?? "";
+      if (name === "pnpm" || name === "yarn") return name;
+      if (name === "npm" || name === "bun") return "npm";
+    }
+  } catch {
+  }
+  const lockfiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "npm"],
+    ["bun.lock", "npm"],
+    ["package-lock.json", "npm"],
+    ["npm-shrinkwrap.json", "npm"]
+  ];
+  for (const [file, manager] of lockfiles) {
+    try {
+      await fs.stat(`${dir}/${file}`);
+      return manager;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolvePath(input, ctx) {
+  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
+}
+function allowedRoots(ctx) {
+  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];
+}
+function isInsideAny(target, roots) {
+  return roots.some((root) => {
+    const rel = path.relative(root, target);
+    return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+  });
+}
+function ensureInsideRoot(absPath, ctx) {
+  const target = path.resolve(absPath);
+  if (ctx.allowOutsideProjectRoot) return target;
+  if (isInsideAny(target, allowedRoots(ctx))) return target;
+  throw new Error(`Path "${absPath}" is outside project root "${path.resolve(ctx.projectRoot)}"`);
+}
+function safeResolve(input, ctx) {
+  return ensureInsideRoot(resolvePath(input, ctx), ctx);
+}
+async function assertRealInsideRoot(absPath, ctx) {
+  await resolveRealInsideRoot(absPath, ctx);
+}
+async function resolveRealInsideRoot(absPath, ctx) {
+  if (ctx.allowOutsideProjectRoot) return absPath;
+  const realRoots = await Promise.all(
+    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
+  );
+  let probe = absPath;
+  const pendingTail = [];
+  for (; ; ) {
+    let real;
+    try {
+      real = await fsp.realpath(probe);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const parent = path.dirname(probe);
+        if (parent === probe) return absPath;
+        pendingTail.unshift(path.basename(probe));
+        probe = parent;
+        continue;
+      }
+      throw err;
+    }
+    const candidate = pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
+    if (isInsideAny(candidate, realRoots)) {
+      return candidate;
+    }
+    throw new Error(
+      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
+    );
+  }
+}
+async function safeResolveReal(input, ctx) {
+  const abs = safeResolve(input, ctx);
+  return await resolveRealInsideRoot(abs, ctx);
+}
+function truncateDiffPayload(diff, maxBytes) {
+  const total = Buffer.byteLength(diff, "utf8");
+  if (total <= maxBytes) return { text: diff, truncated: false };
+  const MARKER_RESERVE = 96;
+  let head = takeHeadBytes(diff, Math.max(0, maxBytes - MARKER_RESERVE));
+  const nl = head.lastIndexOf("\n");
+  if (nl > 0) head = head.slice(0, nl);
+  const kept = Buffer.byteLength(head, "utf8");
+  return {
+    text: `${head}
+\u2026[diff truncated: ${total - kept} of ${total} bytes omitted]`,
+    truncated: true
+  };
+}
+function truncateMiddle(s, max) {
+  if (Buffer.byteLength(s, "utf8") <= max) return s;
+  const half = Math.floor(max / 2);
+  return s.slice(0, half) + `
+\u2026[truncated ${Buffer.byteLength(s, "utf8") - max} bytes from middle]\u2026
+` + s.slice(-half);
+}
+function isBinaryBuffer(buf) {
+  const len = Math.min(buf.length, 8192);
+  for (let i = 0; i < len; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+var COMMAND_OUTPUT_MAX_BYTES = 32768;
+var REPEAT_RUN_THRESHOLD = 3;
+function collapseCarriageReturns(text) {
+  const lf = text.replace(/\r\n/g, "\n");
+  if (!lf.includes("\r")) return lf;
+  return lf.split("\n").map((line) => line.includes("\r") ? line.slice(line.lastIndexOf("\r") + 1) : line).join("\n");
+}
+function collapseConsecutiveDuplicates(text, minRun = REPEAT_RUN_THRESHOLD) {
+  const lines = text.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    let j = i + 1;
+    while (j < lines.length && lines[j] === lines[i]) j++;
+    const run = j - i;
+    if (run >= minRun) {
+      out.push(lines[i], `\u2026 \u27E8repeated ${run}\xD7\u27E9`);
+    } else {
+      for (let k = i; k < j; k++) out.push(lines[k]);
+    }
+    i = j;
+  }
+  return out.join("\n");
+}
+function takeHeadBytes(s, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(s, "utf8") <= maxBytes) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (Buffer.byteLength(s.slice(0, mid), "utf8") <= maxBytes) lo = mid;
+    else hi = mid - 1;
+  }
+  return s.slice(0, lo);
+}
+function takeTailBytes(s, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(s, "utf8") <= maxBytes) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (Buffer.byteLength(s.slice(s.length - mid), "utf8") <= maxBytes) lo = mid;
+    else hi = mid - 1;
+  }
+  return s.slice(s.length - lo);
+}
+function truncateHeadTail(s, maxBytes) {
+  const total = Buffer.byteLength(s, "utf8");
+  if (total <= maxBytes) return s;
+  const MARKER_RESERVE = 64;
+  const avail = Math.max(0, maxBytes - MARKER_RESERVE);
+  const headBudget = Math.floor(avail * 0.45);
+  const head = takeHeadBytes(s, headBudget);
+  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, "utf8"));
+  const kept = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
+  return `${head}
+\u2026[truncated ${total - kept} bytes]\u2026
+${tail}`;
+}
+function normalizeCommandOutput(raw, opts = {}) {
+  if (!raw) return raw;
+  let text = Core.stripAnsi(raw);
+  text = collapseCarriageReturns(text);
+  text = text.replace(/[ \t]+$/gm, "");
+  text = collapseConsecutiveDuplicates(text);
+  text = text.replace(/\n{3,}/g, "\n\n");
+  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);
+}
+
+export {
+  sha256hex,
+  detectPackageManager,
+  ensureInsideRoot,
+  assertRealInsideRoot,
+  resolveRealInsideRoot,
+  safeResolveReal,
+  truncateDiffPayload,
+  truncateMiddle,
+  isBinaryBuffer,
+  COMMAND_OUTPUT_MAX_BYTES,
+  normalizeCommandOutput
+};
+//# sourceMappingURL=chunk-D33S4RQG.js.map