bytecut 0.0.0-stage → 0.0.1

package/dist/audit-HVW4EOLP.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import {
+  svgoEngine
+} from "./chunk-LTWUPQDT.js";
+import {
+  audit
+} from "./chunk-N536JFSF.js";
+import {
+  formatAuditReport
+} from "./chunk-CEZK3RQJ.js";
+import "./chunk-3DBJKHOD.js";
+import "./chunk-5R7LR5BB.js";
+import {
+  sharpImageEngine
+} from "./chunk-XFJ3HW4X.js";
+import "./chunk-NAKV7HS5.js";
+import {
+  configArg,
+  createVideoEngine,
+  discover,
+  ffmpegInstallText,
+  ffmpegStatus,
+  noAssetsMessage
+} from "./chunk-4XOB3C34.js";
+import "./chunk-M6ZDSATP.js";
+import "./chunk-WE7AEDVI.js";
+import "./chunk-YBEC5QGV.js";
+import "./chunk-LHTI3JMC.js";
+import {
+  guarded
+} from "./chunk-J2XJO4JZ.js";
+import "./chunk-TWI2OZJZ.js";
+
+// src/cli/commands/audit.ts
+import { defineCommand } from "citty";
+var audit_default = defineCommand({
+  meta: {
+    name: "audit",
+    description: "Report what is too heavy in your image assets, with estimated savings"
+  },
+  args: {
+    ...configArg,
+    json: { type: "boolean", description: "Print the report as JSON" },
+    all: { type: "boolean", description: "Show every finding instead of the first 10 per rule" },
+    "out-dir": {
+      type: "string",
+      description: "Output folder (default: from the detected framework)"
+    },
+    ffmpeg: {
+      type: "string",
+      description: "Path to the ffmpeg binary (else BYTECUT_FFMPEG, then PATH)"
+    },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" },
+    cache: {
+      type: "boolean",
+      default: true,
+      description: "Keep the analysis cache in <outDir>/.bytecut-cache (--no-cache to avoid writing)"
+    }
+  },
+  run: guarded(async ({ args }) => {
+    const found = await discover(args._.map(String), args["out-dir"], args.config);
+    const { config } = found;
+    if (found.scanInputs.length === 0) {
+      console.error(noAssetsMessage("audit", found.project));
+      process.exitCode = 2;
+      return;
+    }
+    const report = await audit({
+      projectRoot: found.projectRoot,
+      engine: sharpImageEngine,
+      svgEngine: svgoEngine,
+      inputs: found.scanInputs,
+      outDir: found.outDir,
+      staticRoot: found.project.staticRoot,
+      ffmpeg: ffmpegStatus(config),
+      videoEngine: createVideoEngine({ ffmpeg: args.ffmpeg, ffprobe: args.ffprobe }, config),
+      policy: config.policy,
+      exclude: config.exclude,
+      ignore: config.auditIgnore,
+      settings: config.rules,
+      budgets: config.budgets,
+      needsFfmpeg: ffmpegInstallText(),
+      persistCache: args.cache !== false
+    });
+    if (args.json) {
+      process.stdout.write(
+        `${JSON.stringify({ version: 1, project: found.project, ...report }, null, 2)}
+`
+      );
+      return;
+    }
+    console.log(formatAuditReport(report, { all: Boolean(args.all) }));
+  })
+});
+export {
+  audit_default as default
+};

package/dist/check-YONIQTM7.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+import {
+  svgoEngine
+} from "./chunk-LTWUPQDT.js";
+import {
+  audit
+} from "./chunk-N536JFSF.js";
+import {
+  formatAuditReport
+} from "./chunk-CEZK3RQJ.js";
+import "./chunk-3DBJKHOD.js";
+import "./chunk-5R7LR5BB.js";
+import {
+  sharpImageEngine
+} from "./chunk-XFJ3HW4X.js";
+import "./chunk-NAKV7HS5.js";
+import {
+  configArg,
+  createVideoEngine,
+  discover,
+  ffmpegInstallText,
+  ffmpegStatus,
+  noAssetsMessage
+} from "./chunk-4XOB3C34.js";
+import {
+  run
+} from "./chunk-M6ZDSATP.js";
+import {
+  toPosix
+} from "./chunk-WE7AEDVI.js";
+import "./chunk-YBEC5QGV.js";
+import "./chunk-LHTI3JMC.js";
+import {
+  BytecutError,
+  CONFIG_FILES,
+  formatBytes,
+  percentChange,
+  plural
+} from "./chunk-TWI2OZJZ.js";
+
+// src/cli/commands/check.ts
+import { defineCommand } from "citty";
+
+// src/core/commands/check.ts
+function evaluate(report, options = {}) {
+  const failOn = options.failOn ?? "error";
+  const changed = options.changed ?? null;
+  const inScope = (f) => !changed || changed.all || f.source === void 0 || changed.files.has(f.source);
+  const findings = report.findings.filter(inScope);
+  const failing = findings.filter(
+    (f) => f.severity === "error" || failOn === "warn" && f.severity === "warn"
+  );
+  const count = (s) => findings.filter((f) => f.severity === s).length;
+  return {
+    ok: failing.length === 0,
+    failOn,
+    findings,
+    failing,
+    counts: { error: count("error"), warn: count("warn"), info: count("info") },
+    scope: changed ? {
+      base: changed.base,
+      changedFiles: changed.files.size,
+      everything: changed.all,
+      dropped: report.findings.length - findings.length
+    } : null
+  };
+}
+
+// src/core/git/changed.ts
+var fail = (message, cause) => new BytecutError("GIT_UNAVAILABLE", message, cause ? { cause } : void 0);
+function nulList(stdout) {
+  return stdout.split("\0").filter((p) => p.length > 0);
+}
+async function changedFiles(options) {
+  const { projectRoot, base, run: run2 } = options;
+  const git = async (...args) => {
+    const { stdout } = await run2("git", ["-C", projectRoot, ...args]);
+    return stdout;
+  };
+  if (base.startsWith("-")) throw fail(`"${base}" is not a git ref.`);
+  try {
+    await git("rev-parse", "--is-inside-work-tree");
+  } catch (error) {
+    const missing = error.code === "ENOENT";
+    throw fail(
+      missing ? "--changed needs git, which was not found on PATH." : "--changed needs a git repository; this folder is not inside one.",
+      error
+    );
+  }
+  let mergeBase;
+  try {
+    await git("rev-parse", "--verify", "--quiet", `${base}^{commit}`);
+  } catch (error) {
+    const shallow = (await git("rev-parse", "--is-shallow-repository").catch(() => "")).trim();
+    throw fail(
+      `The ref "${base}" is not in this repository.` + (shallow === "true" ? " This is a shallow clone: fetch more history first (for GitHub Actions, `fetch-depth: 0` on actions/checkout)." : " bytecut never fetches; fetch it yourself if it is a remote branch."),
+      error
+    );
+  }
+  try {
+    mergeBase = (await git("merge-base", base, "HEAD")).trim();
+  } catch (error) {
+    throw fail(
+      `No common ancestor between "${base}" and HEAD. In a shallow clone, fetch more history (for GitHub Actions, \`fetch-depth: 0\`).`,
+      error
+    );
+  }
+  const tracked = nulList(
+    await git(
+      "diff",
+      "--name-only",
+      "--relative",
+      "--diff-filter=ACMRT",
+      "-z",
+      mergeBase,
+      "--",
+      "."
+    )
+  );
+  const untracked = nulList(
+    await git("ls-files", "--others", "--exclude-standard", "-z", "--", ".")
+  );
+  const files = new Set([...tracked, ...untracked].map(toPosix));
+  const configNames = new Set(CONFIG_FILES);
+  const all = [...files].some((f) => configNames.has(f));
+  return { base, files, all };
+}
+
+// src/core/report/json.ts
+function renderJsonReport(report, verdict) {
+  return `${JSON.stringify(
+    {
+      version: 1,
+      ok: verdict.ok,
+      failOn: verdict.failOn,
+      counts: verdict.counts,
+      changed: verdict.scope,
+      findings: verdict.findings,
+      failing: verdict.failing.length,
+      scanned: report.counts,
+      totals: report.totals,
+      unprobed: report.unprobed,
+      notes: report.notes
+    },
+    null,
+    2
+  )}
+`;
+}
+
+// src/core/report/markdown.ts
+var MARKDOWN_LIMIT = 6e4;
+var ROWS_PER_RULE = 20;
+var SEVERITY_ORDER = { error: 0, warn: 1, info: 2 };
+function cell(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/[`*_<>[\]]/g, (c) => `\\${c}`).replace(/\r?\n/g, " ");
+}
+function size(f) {
+  if (f.current !== void 0 && f.estimated !== void 0) {
+    return `${formatBytes(f.current)} \u2192 ~${formatBytes(f.estimated)} (${percentChange(f.current, f.estimated)})`;
+  }
+  return f.current !== void 0 ? formatBytes(f.current) : "";
+}
+function renderMarkdownReport(report, verdict) {
+  const out = [];
+  const { counts, scope } = verdict;
+  out.push(`## bytecut check: ${verdict.ok ? "passed" : "failed"}`, "");
+  const summary = [
+    `${plural(counts.error, "error")}, ${plural(counts.warn, "warning")}, ${counts.info} info`
+  ];
+  const c = report.counts;
+  summary.push(
+    `scanned ${plural(c.images + c.skipped, "image")}, ${plural(c.svgs, "SVG")}, ${plural(c.videos, "video")} (${formatBytes(report.totals.sourceBytes)})`
+  );
+  if (scope) {
+    summary.push(
+      scope.everything ? `a bytecut config changed since \`${cell(scope.base)}\`, so every file is in scope` : `${plural(scope.changedFiles, "file")} changed since \`${cell(scope.base)}\``
+    );
+  }
+  out.push(summary.join(" \xB7 "), "");
+  if (!verdict.ok) {
+    out.push(
+      `Failing on ${verdict.failOn === "warn" ? "warnings and errors" : "errors"}: ${plural(verdict.failing.length, "finding")}.`,
+      ""
+    );
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of verdict.findings) groups.set(f.ruleId, [...groups.get(f.ruleId) ?? [], f]);
+  const ordered = [...groups.entries()].sort(([ia, a], [ib, b]) => {
+    const d = (SEVERITY_ORDER[a[0].severity] ?? 9) - (SEVERITY_ORDER[b[0].severity] ?? 9);
+    return d || (ia < ib ? -1 : 1);
+  });
+  const tail = [];
+  if (report.unprobed.length > 0) {
+    tail.push(
+      `> ${plural(report.unprobed.length, "video")} not analysed because ffmpeg was not found.`
+    );
+  }
+  for (const note of report.notes) tail.push(`> ${cell(note)}`);
+  let omitted = 0;
+  for (const [ruleId, findings] of ordered) {
+    const section = [
+      `### \`${ruleId}\` \xB7 ${findings[0].severity} \xB7 ${plural(findings.length, "file")}`,
+      "",
+      "| File | Size | Detail |",
+      "| --- | --- | --- |"
+    ];
+    for (const f of findings.slice(0, ROWS_PER_RULE)) {
+      const where = f.path ? `${f.source ?? ""} \u2192 ${f.path}` : f.source ?? "(project)";
+      section.push(`| ${cell(where)} | ${cell(size(f))} | ${cell(f.message)} |`);
+    }
+    if (findings.length > ROWS_PER_RULE) {
+      section.push("", `\u2026 and ${findings.length - ROWS_PER_RULE} more.`);
+    }
+    section.push("");
+    const text = section.join("\n");
+    if (out.join("\n").length + text.length + tail.join("\n").length + 200 > MARKDOWN_LIMIT) {
+      omitted += findings.length;
+      continue;
+    }
+    out.push(text);
+  }
+  if (omitted > 0) {
+    out.push(
+      `_${plural(omitted, "more finding")} not shown: this comment hit its size limit. Run \`bytecut check\` locally for the full list._`,
+      ""
+    );
+  }
+  out.push(...tail);
+  return `${out.join("\n").trimEnd()}
+`;
+}
+
+// src/cli/commands/check.ts
+var EXIT = { ok: 0, failed: 1, unusable: 2 };
+var REPORTS = ["md", "json"];
+var FAIL_ON = ["error", "warn"];
+var check_default = defineCommand({
+  meta: {
+    name: "check",
+    description: "CI mode: audit the project and exit non-zero if any finding is an error"
+  },
+  args: {
+    ...configArg,
+    // Declared boolean so a bare `--changed` never swallows the flag after it; the base ref
+    // is read from the raw arguments below.
+    changed: {
+      type: "boolean",
+      description: "Only report files changed since a git ref: --changed (HEAD, i.e. local changes), --changed origin/main or --changed=origin/main"
+    },
+    report: { type: "string", description: "Print a report on stdout: md or json" },
+    "fail-on": {
+      type: "string",
+      description: "Lowest severity that fails the check: error (default) or warn"
+    },
+    all: { type: "boolean", description: "Text report: every finding, not the first 10 per rule" },
+    "out-dir": {
+      type: "string",
+      description: "Output folder (default: from the detected framework)"
+    },
+    ffmpeg: { type: "string", description: "Path to the ffmpeg binary" },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" }
+  },
+  run: async ({ args, rawArgs }) => {
+    try {
+      process.exitCode = await check(args, rawArgs);
+    } catch (error) {
+      if (!(error instanceof BytecutError)) throw error;
+      console.error(`bytecut: ${error.message} [${error.code}]`);
+      process.exitCode = EXIT.unusable;
+    }
+  }
+});
+async function check(args, rawArgs) {
+  const report = args.report;
+  if (report !== void 0 && !REPORTS.includes(report)) {
+    throw new BytecutError("BAD_ARGUMENTS", `--report must be md or json, not "${report}".`);
+  }
+  const failOn = args["fail-on"] ?? "error";
+  if (!FAIL_ON.includes(failOn)) {
+    throw new BytecutError("BAD_ARGUMENTS", `--fail-on must be error or warn, not "${failOn}".`);
+  }
+  let changedBase = null;
+  const positional = args._.map(String);
+  const at = rawArgs.findIndex((a) => a === "--changed" || a.startsWith("--changed="));
+  if (at !== -1) {
+    const arg = rawArgs[at];
+    const next = rawArgs[at + 1];
+    if (arg.includes("=")) changedBase = arg.slice(arg.indexOf("=") + 1) || "HEAD";
+    else if (next !== void 0 && !next.startsWith("-")) {
+      changedBase = next;
+      const i = positional.indexOf(next);
+      if (i !== -1) positional.splice(i, 1);
+    } else changedBase = "HEAD";
+  }
+  const found = await discover(
+    positional,
+    args["out-dir"],
+    args.config
+  );
+  if (found.scanInputs.length === 0) {
+    console.error(noAssetsMessage("check", found.project));
+    return EXIT.unusable;
+  }
+  const { config } = found;
+  const changed = changedBase === null ? null : await changedFiles({ projectRoot: found.projectRoot, base: changedBase, run });
+  const result = await audit({
+    projectRoot: found.projectRoot,
+    engine: sharpImageEngine,
+    svgEngine: svgoEngine,
+    inputs: found.scanInputs,
+    outDir: found.outDir,
+    staticRoot: found.project.staticRoot,
+    ffmpeg: ffmpegStatus(config),
+    videoEngine: createVideoEngine(
+      { ffmpeg: args.ffmpeg, ffprobe: args.ffprobe },
+      config
+    ),
+    needsFfmpeg: ffmpegInstallText(),
+    persistCache: false,
+    policy: config.policy,
+    exclude: config.exclude,
+    ignore: config.auditIgnore,
+    settings: config.rules,
+    budgets: config.budgets
+  });
+  const verdict = evaluate(result, { failOn, changed });
+  if (report === "json") process.stdout.write(renderJsonReport(result, verdict));
+  else if (report === "md") process.stdout.write(renderMarkdownReport(result, verdict));
+  else {
+    const view = { ...result, findings: verdict.findings };
+    console.log(formatAuditReport(view, { all: Boolean(args.all) }));
+    if (verdict.scope) {
+      console.log(
+        verdict.scope.everything ? `A bytecut config changed since ${verdict.scope.base}: every file is in scope.` : `${plural(verdict.scope.changedFiles, "file")} changed since ${verdict.scope.base}; findings about other files are not shown (${verdict.scope.dropped} hidden).`
+      );
+    }
+  }
+  const summary = `${plural(verdict.counts.error, "error")}, ${plural(verdict.counts.warn, "warning")}`;
+  console.error(
+    verdict.ok ? `bytecut check: passed (${summary}).` : `bytecut check: failed (${plural(verdict.failing.length, "failing finding")}; ${summary}).`
+  );
+  return verdict.ok ? EXIT.ok : EXIT.failed;
+}
+export {
+  EXIT,
+  check_default as default
+};

package/dist/chunk-326CQQWX.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import {
+  ffmpegDirOf,
+  installHint,
+  pickAv1Encoder,
+  probeFfmpeg,
+  probeFfprobeVersion,
+  resolveBinary
+} from "./chunk-YBEC5QGV.js";
+
+// src/core/doctor/report.ts
+var MIN_NODE_MAJOR = 22;
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function collectDoctorReport(deps, options = {}) {
+  const major = Number.parseInt(deps.nodeVersion.replace(/^v/, ""), 10);
+  const node = { version: deps.nodeVersion, supported: major >= MIN_NODE_MAJOR };
+  let sharp;
+  try {
+    sharp = { available: true, ...await deps.loadSharp() };
+  } catch (error) {
+    sharp = { available: false, error: message(error) };
+  }
+  const base = { env: deps.env, platform: deps.platform };
+  const ffmpegResolved = resolveBinary(
+    "ffmpeg",
+    { ...base, flag: options.ffmpegFlag, config: options.ffmpegConfig },
+    deps
+  );
+  const ffprobeResolved = resolveBinary(
+    "ffprobe",
+    {
+      ...base,
+      flag: options.ffprobeFlag,
+      config: options.ffprobeConfig,
+      ffmpegDir: ffmpegDirOf(ffmpegResolved)
+    },
+    deps
+  );
+  const ffmpeg = { resolved: ffmpegResolved };
+  if (ffmpegResolved.found) {
+    try {
+      ffmpeg.info = await probeFfmpeg(ffmpegResolved.path, deps.run);
+      ffmpeg.version = ffmpeg.info.version;
+    } catch (error) {
+      ffmpeg.error = message(error);
+    }
+  }
+  const ffprobe = { resolved: ffprobeResolved };
+  if (ffprobeResolved.found) {
+    try {
+      ffprobe.version = await probeFfprobeVersion(ffprobeResolved.path, deps.run);
+    } catch (error) {
+      ffprobe.error = message(error);
+    }
+  }
+  const scorerResolved = resolveBinary(
+    "ssimulacra2",
+    {
+      env: deps.env,
+      platform: deps.platform,
+      flag: options.ssimulacra2Flag,
+      config: options.ssimulacra2Config
+    },
+    deps
+  );
+  const caps = ffmpeg.info?.capabilities;
+  const encoders = {
+    av1: caps ? pickAv1Encoder(caps) : null,
+    h264: caps?.libx264 ?? false,
+    vp9: caps?.libvpxVp9 ?? false,
+    vmaf: caps?.libvmaf ?? false
+  };
+  const degradations = [];
+  const hint = installHint(deps.platform, deps.osReleaseId);
+  if (!ffmpegResolved.found) {
+    degradations.push(
+      ffmpegResolved.attempted ? `ffmpeg not found at ${ffmpegResolved.attempted} (from ${sourceLabel(ffmpegResolved.source)}). Videos and GIFs will be marked "needs ffmpeg"; images are unaffected.` : `ffmpeg not found. Videos and GIFs will be marked "needs ffmpeg"; images are unaffected. Install it with: ${hint}`
+    );
+  } else if (ffmpeg.error) {
+    degradations.push(
+      `ffmpeg at ${ffmpegResolved.path} could not be run (${ffmpeg.error}). Videos and GIFs will be marked "needs ffmpeg".`
+    );
+  } else {
+    if (!ffprobeResolved.found || ffprobe.error) {
+      degradations.push(
+        `ffprobe is not usable. Videos cannot be probed, so they will be marked "needs ffmpeg". It normally ships alongside ffmpeg; install it with: ${hint}`
+      );
+    }
+    if (!encoders.av1) {
+      degradations.push(
+        "No AV1 encoder (libsvtav1 / libaom-av1). AV1 outputs will be skipped; H.264 and poster are still produced."
+      );
+    }
+    if (!encoders.h264) {
+      degradations.push("libx264 is missing. H.264 MP4 fallbacks cannot be produced.");
+    }
+    if (!encoders.vmaf) {
+      degradations.push(
+        "libvmaf is missing. Fixed quality settings from the preset target will be used; the VMAF search is skipped."
+      );
+    }
+  }
+  return {
+    node,
+    sharp,
+    ffmpeg,
+    ffprobe,
+    scorer: { kind: scorerResolved.found ? "native" : "wasm", resolved: scorerResolved },
+    encoders,
+    degradations,
+    ok: node.supported && sharp.available
+  };
+}
+function sourceLabel(source) {
+  switch (source) {
+    case "flag":
+      return "flag";
+    case "env":
+      return "environment variable";
+    case "config":
+      return "config";
+    case "ffmpeg-dir":
+      return "ffmpeg's directory";
+    case "path":
+      return "PATH";
+    default:
+      return "not found";
+  }
+}
+function binaryLine(label, report) {
+  const { resolved } = report;
+  if (!resolved.found) {
+    return resolved.attempted ? `${label}: not found at ${resolved.attempted} (${sourceLabel(resolved.source)})` : `${label}: not found`;
+  }
+  const detail = report.error ? `failed to run: ${report.error}` : `version ${report.version}`;
+  return `${label}: ${resolved.path} (${sourceLabel(resolved.source)}), ${detail}`;
+}
+var yesNo = (value) => value ? "yes" : "no";
+function formatDoctorReport(report) {
+  const lines = ["bytecut doctor", ""];
+  lines.push(
+    `Node:    ${report.node.version}${report.node.supported ? "" : ` (needs >= ${MIN_NODE_MAJOR})`}`
+  );
+  lines.push(
+    report.sharp.available ? `sharp:   ${report.sharp.version} (libvips ${report.sharp.libvips})` : `sharp:   unavailable (${report.sharp.error})`
+  );
+  lines.push(binaryLine("ffmpeg ", report.ffmpeg));
+  lines.push(binaryLine("ffprobe", report.ffprobe));
+  {
+    const { kind, resolved } = report.scorer;
+    lines.push(
+      kind === "native" && resolved.found ? `scorer:  native ssimulacra2 at ${resolved.path} (${sourceLabel(resolved.source)})` : resolved.found === false && resolved.attempted ? `scorer:  built-in WebAssembly (no ssimulacra2 at ${resolved.attempted}, from ${sourceLabel(resolved.source)})` : "scorer:  built-in WebAssembly SSIMULACRA2 (no native ssimulacra2 needed)"
+    );
+  }
+  if (report.ffmpeg.info) {
+    lines.push("", "Encoders:");
+    lines.push(`  AV1:     ${report.encoders.av1 ?? "none"}`);
+    lines.push(`  H.264:   ${yesNo(report.encoders.h264)} (libx264)`);
+    lines.push(`  VP9:     ${yesNo(report.encoders.vp9)} (libvpx-vp9)`);
+    lines.push(`  libvmaf: ${yesNo(report.encoders.vmaf)}`);
+  }
+  if (report.project) {
+    const p = report.project;
+    lines.push("", `Project: ${p.framework} \u2192 ${p.outDir}`);
+    lines.push(`Config:  ${p.configFile ?? "none (zero-config)"}`);
+    if (p.configError) lines.push(`  problem: ${p.configError}`);
+    if (p.outDirIgnored) {
+      lines.push(
+        `  note: ${p.outDir} is matched by a .gitignore. bytecut's outputs are meant to be committed, so deploys need no encoding step. Nothing was changed.`
+      );
+    }
+  }
+  lines.push("");
+  if (report.degradations.length === 0) {
+    lines.push("Everything is available. No degradation.");
+  } else {
+    lines.push("Degraded:");
+    for (const item of report.degradations) lines.push(`  - ${item}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  collectDoctorReport,
+  formatDoctorReport
+};