@wrongstack/tools 0.313.0 → 0.313.1

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

package/dist/chunk-DIJKHSUO.js

@@ -0,0 +1,134 @@
+import {
+  tryLegacyCodeOperation
+} from "./chunk-NHA6BEIH.js";
+import {
+  spawnStream
+} from "./chunk-MAN26PZ5.js";
+import {
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/lint.ts
+var lintTool = {
+  name: "lint",
+  category: "Code Quality",
+  description: "Run the project linter (primarily Biome in this repo). Detects style violations, potential bugs, and formatting issues.",
+  usageHint: "RUN OFTEN DURING DEVELOPMENT:\n\n- `fix: true` will automatically correct what it can.\n- Target specific files or globs when you only want to check part of the project.\nThis is a fast and important quality gate. Use it before typecheck in most workflows.",
+  permission: "confirm",
+  mutating: false,
+  timeoutMs: 6e4,
+  capabilities: ["shell.restricted"],
+  icon: "code",
+  inputSchema: {
+    type: "object",
+    properties: {
+      files: {
+        type: "string",
+        description: 'Files/patterns: single path, comma-separated list, or glob (e.g. "src/**/*.ts")'
+      },
+      fix: { type: "boolean", description: "Auto-fix fixable issues (default: false)" },
+      linter: {
+        type: "string",
+        enum: ["biome", "eslint", "tslint", "auto"],
+        description: "Linter to use (default: auto-detect)"
+      },
+      cwd: { type: "string", description: "Working directory (default: cwd)" }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = lintTool.executeStream;
+    if (!executeStream) throw new Error("lintTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("lint: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    const linter = input.linter ?? "auto";
+    if (linter === "auto" && !input.files) {
+      const bridge = await tryLegacyCodeOperation("lint", {
+        cwd,
+        projectRoot: ctx.projectRoot,
+        signal: opts.signal
+      });
+      if (bridge?.run) {
+        const run = bridge.run;
+        yield {
+          type: "final",
+          output: {
+            linter: bridge.language,
+            files_checked: 0,
+            errors: run.summary.errors,
+            warnings: run.summary.warnings,
+            output: normalizeCommandOutput(run.output || run.error || ""),
+            fix_applied: false,
+            truncated: run.truncated
+          }
+        };
+        return;
+      }
+    }
+    const detected = linter === "auto" ? await detectLinter(cwd) : linter;
+    if (!detected) {
+      yield {
+        type: "final",
+        output: {
+          linter: "none",
+          files_checked: 0,
+          errors: 0,
+          warnings: 0,
+          output: "No linter found (biome.json, .eslintrc, tslint.json)",
+          fix_applied: false,
+          truncated: false
+        }
+      };
+      return;
+    }
+    yield { type: "log", text: `Running ${detected}\u2026`, data: { linter: detected } };
+    const args = ["lint"];
+    if (input.fix) args.push("--write");
+    if (input.files) {
+      const files = Array.isArray(input.files) ? input.files : input.files.split(",");
+      args.push("--", ...files.map((f) => f.trim()));
+    }
+    const cmd = detected === "biome" ? "biome" : detected;
+    const result = yield* spawnStream({ cmd, args, cwd, signal: opts.signal, maxBytes: 1e5 });
+    const errors = [...result.stdout.matchAll(/\berror\b/gi)].length;
+    const warnings = [...result.stdout.matchAll(/\bwarning\b/gi)].length;
+    yield {
+      type: "final",
+      output: {
+        linter: detected,
+        files_checked: input.files ? Array.isArray(input.files) ? input.files.length : input.files.split(",").length : 0,
+        errors,
+        warnings,
+        output: normalizeCommandOutput(result.stdout),
+        fix_applied: input.fix ?? false,
+        truncated: result.truncated
+      }
+    };
+  }
+};
+async function detectLinter(cwd) {
+  const { stat } = await import("node:fs/promises");
+  const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
+  for (const f of checks) {
+    try {
+      await stat(`${cwd}/${f}`);
+      if (f.includes("biome")) return "biome";
+      if (f.includes("eslint")) return "eslint";
+      if (f.includes("tslint")) return "tslint";
+    } catch {
+    }
+  }
+  return "biome";
+}
+
+export {
+  lintTool
+};
+//# sourceMappingURL=chunk-DIJKHSUO.js.map