@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-UTV7YAW7.js

@@ -0,0 +1,178 @@
+import {
+  tryLegacyCodeOperation
+} from "./chunk-NHA6BEIH.js";
+import {
+  spawnStream
+} from "./chunk-MAN26PZ5.js";
+import {
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/format.ts
+var formatTool = {
+  name: "format",
+  category: "Code Quality",
+  description: "Format source files according to project style (Biome). Can also run in check-only mode.",
+  usageHint: "RUN REGULARLY:\n\n- Use on changed files before committing.\n- `check: true` verifies formatting without making changes (useful in CI-like flows).\nThis project has very consistent formatting expectations. Always ensure your changes are formatted.",
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The files being rewritten are the subject; the fixer is how, not what.
+  subjectKey: "files",
+  mutating: true,
+  capabilities: ["fs.write", "shell.restricted"],
+  icon: "code",
+  timeoutMs: 6e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      files: {
+        type: "string",
+        description: "Files/patterns: single path, comma-separated list, or glob"
+      },
+      fixer: {
+        type: "string",
+        enum: ["biome", "prettier", "auto"],
+        description: "Formatter to use (default: auto-detect)"
+      },
+      check: {
+        type: "boolean",
+        description: "Verify only, do not modify files (default: false)"
+      },
+      cwd: { type: "string", description: "Working directory (default: cwd)" }
+    }
+  },
+  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)) {
+      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;
+    const fixer = input.fixer ?? "auto";
+    if (fixer === "auto" && !input.files) {
+      const op = input.check ? "format-check" : "format-write";
+      const bridge = await tryLegacyCodeOperation(op, {
+        cwd,
+        projectRoot: ctx.projectRoot,
+        signal: opts.signal
+      });
+      if (bridge?.run) {
+        const run = bridge.run;
+        yield {
+          type: "final",
+          output: {
+            fixer: bridge.language,
+            // Language-bridge runs don't report per-file counts.
+            files_checked: void 0,
+            files_changed: void 0,
+            output: normalizeCommandOutput(run.output || run.error || ""),
+            truncated: run.truncated
+          }
+        };
+        return;
+      }
+    }
+    const detected = fixer === "auto" ? await detectFixer(cwd) : fixer;
+    if (!detected) {
+      yield {
+        type: "final",
+        output: {
+          fixer: "none",
+          files_checked: 0,
+          files_changed: 0,
+          output: "No formatter found (biome.json, .prettierrc)",
+          truncated: false
+        }
+      };
+      return;
+    }
+    yield {
+      type: "log",
+      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()) : [];
+    let args;
+    if (detected === "prettier") {
+      args = [input.check ? "--check" : "--write"];
+      args.push(...fileList.length > 0 ? fileList : ["."]);
+    } else {
+      args = ["format", input.check ? "--check" : "--write"];
+      if (fileList.length > 0) args.push("--", ...fileList);
+    }
+    const result = yield* spawnStream({
+      cmd: detected,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 1e5
+    });
+    const combinedOut = `${result.stdout}
+${result.stderr}`;
+    const counts = parseFormatterCounts(detected, combinedOut);
+    yield {
+      type: "final",
+      output: {
+        fixer: detected,
+        files_checked: counts.checked,
+        files_changed: counts.changed,
+        output: normalizeCommandOutput(result.stdout || result.stderr || result.error || ""),
+        truncated: result.truncated
+      }
+    };
+  }
+};
+function parseFormatterCounts(fixer, output) {
+  if (fixer !== "biome") return { checked: void 0, changed: void 0 };
+  const checkedMatch = /\b(?:Checked|Formatted)\s+(\d+)\s+files?\b/i.exec(output);
+  const changedMatch = /\bFixed\s+(\d+)\s+files?\b/i.exec(output);
+  return {
+    checked: checkedMatch?.[1] !== void 0 ? Number(checkedMatch[1]) : void 0,
+    changed: changedMatch?.[1] !== void 0 ? Number(changedMatch[1]) : void 0
+  };
+}
+async function detectFixer(cwd) {
+  const fs = await import("node:fs/promises");
+  const exists = async (file) => {
+    try {
+      await fs.stat(`${cwd}/${file}`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (await exists("biome.json") || await exists("biome.jsonc")) return "biome";
+  const PRETTIER_CONFIGS = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yml",
+    ".prettierrc.yaml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs"
+  ];
+  for (const cfg of PRETTIER_CONFIGS) {
+    if (await exists(cfg)) return "prettier";
+  }
+  try {
+    const raw = await fs.readFile(`${cwd}/package.json`, "utf8");
+    const pkg = JSON.parse(raw);
+    if (pkg["prettier"] !== void 0) return "prettier";
+  } catch {
+  }
+  return "biome";
+}
+
+export {
+  formatTool
+};
+//# sourceMappingURL=chunk-UTV7YAW7.js.map

package/dist/chunk-V43EQ6VR.js

@@ -0,0 +1,68 @@
+// src/_win32-resolve.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path.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(path.delimiter);
+  for (const dir of pathDirs) {
+    const base = path.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;
+}
+function resolvePowerShell(cmd) {
+  if (process.platform !== "win32") return cmd;
+  const lower = cmd.toLowerCase();
+  if (lower !== "pwsh" && lower !== "powershell" && lower !== "pwsh.exe" && lower !== "powershell.exe") {
+    return resolveWin32Command(cmd);
+  }
+  const primary = lower.startsWith("pwsh") ? "pwsh" : "powershell";
+  const fallback = lower.startsWith("pwsh") ? "powershell" : "pwsh";
+  const resolved = resolveWin32Command(primary);
+  if (resolved === primary) {
+    const fb = resolveWin32Command(fallback);
+    return fb === fallback ? cmd : fb;
+  }
+  return resolved;
+}
+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}"`;
+}
+
+export {
+  resolveWin32Command,
+  resolvePowerShell,
+  assertSafeWin32ShellArgs,
+  buildWin32CmdShimInvocation
+};
+//# sourceMappingURL=chunk-V43EQ6VR.js.map