bytecut 0.0.0-stage → 0.0.1

package/dist/chunk-DJ45NQZD.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+// src/core/scan/gitignore.ts
+import { readFile } from "fs/promises";
+import { join, relative, sep } from "path";
+import ignore from "ignore";
+async function isGitIgnored(projectRoot, absolute) {
+  const rel = relative(projectRoot, absolute);
+  if (rel === "" || rel.startsWith("..")) return false;
+  const parts = rel.split(sep);
+  let dir = projectRoot;
+  const scopes = [];
+  for (let i = 0; i < parts.length; i++) {
+    const text = await readFile(join(dir, ".gitignore"), "utf8").catch(() => null);
+    if (text !== null) scopes.push({ base: dir, matcher: ignore().add(text) });
+    dir = join(dir, parts[i]);
+    for (let s = scopes.length - 1; s >= 0; s--) {
+      const scope = scopes[s];
+      const verdict = scope.matcher.test(`${relative(scope.base, dir).split(sep).join("/")}/`);
+      if (verdict.ignored) return true;
+      if (verdict.unignored) break;
+    }
+  }
+  return false;
+}
+
+export {
+  isGitIgnored
+};

package/dist/chunk-G53LNJ5O.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+// package.json
+var package_default = {
+  name: "bytecut",
+  version: "0.0.1",
+  description: "Audit and optimize images and videos in web projects.",
+  type: "module",
+  license: "MIT",
+  bin: {
+    bytecut: "./dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  scripts: {
+    dev: "tsx src/cli/index.ts",
+    build: "tsup",
+    test: "vitest run",
+    "test:watch": "vitest",
+    lint: "eslint . && prettier --check .",
+    typecheck: "tsc --noEmit",
+    fixtures: "tsx scripts/make-fixtures.ts"
+  },
+  dependencies: {
+    "bytecut-ssimulacra2": "workspace:*",
+    citty: "^0.2.2",
+    ignore: "^7.0.12",
+    ink: "^8.0.0",
+    react: "^19.3.0",
+    sharp: "^0.35.5",
+    "smol-toml": "^1.9.1",
+    svgo: "^4.1.0",
+    zod: "^4.6.5"
+  },
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.6.5",
+    "@types/react": "^19.3.0",
+    eslint: "^10.12.0",
+    "ink-testing-library": "^4.0.0",
+    prettier: "^3.9.9",
+    tsup: "^8.5.1",
+    tsx: "^4.23.15",
+    typescript: "^5.9.3",
+    "typescript-eslint": "^8.71.1",
+    vitest: "^5.0.3"
+  },
+  packageManager: "pnpm@10.18.1"
+};
+
+export {
+  package_default
+};

package/dist/chunk-GMHOU4Y5.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import {
+  escapeGlob
+} from "./chunk-TWI2OZJZ.js";
+
+// src/core/config/choices.ts
+import { stringify as stringifyToml } from "smol-toml";
+function isEmpty(choices) {
+  return choices.outDir === void 0 && choices.publicPath === void 0 && choices.placeholder === void 0 && Object.keys(choices.presets ?? {}).length === 0;
+}
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function applyChoices(existing, choices) {
+  const next = isObject(existing) ? { ...existing } : {};
+  if (choices.outDir !== void 0) next.outDir = choices.outDir;
+  if (choices.publicPath !== void 0) next.publicPath = choices.publicPath;
+  if (choices.placeholder !== void 0) {
+    next.manifest = {
+      ...isObject(next.manifest) ? next.manifest : {},
+      placeholder: choices.placeholder
+    };
+  }
+  const presets = choices.presets ?? {};
+  if (Object.keys(presets).length > 0) {
+    const mine = Object.fromEntries(
+      Object.entries(presets).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([source, preset]) => [escapeGlob(source), preset])
+    );
+    const others = Object.entries(isObject(next.assets) ? next.assets : {}).filter(
+      ([pattern]) => !(pattern in mine)
+    );
+    next.assets = { ...mine, ...Object.fromEntries(others) };
+  }
+  return next;
+}
+function canRewrite(format) {
+  return format === "json";
+}
+function renderConfig(format, data) {
+  if (format === "json") return `${JSON.stringify(data, null, 2)}
+`;
+  if (format === "toml") return `${stringifyToml(data)}
+`;
+  return `export default ${JSON.stringify(data, null, 2)};
+`;
+}
+function renderChoicesSnippet(format, choices) {
+  const fragment = applyChoices({}, choices);
+  return renderConfig(
+    format === "toml" ? "toml" : format === "json" ? "json" : "ts",
+    fragment
+  ).trimEnd();
+}
+
+export {
+  isEmpty,
+  applyChoices,
+  canRewrite,
+  renderConfig,
+  renderChoicesSnippet
+};

package/dist/chunk-J2XJO4JZ.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  BytecutError
+} from "./chunk-TWI2OZJZ.js";
+
+// src/cli/errors.ts
+function guarded(run) {
+  return async (context) => {
+    try {
+      await run(context);
+    } catch (error) {
+      if (!(error instanceof BytecutError)) throw error;
+      console.error(`bytecut: ${error.message} [${error.code}]`);
+      process.exitCode = 1;
+    }
+  };
+}
+
+export {
+  guarded
+};

package/dist/chunk-LHTI3JMC.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import {
+  BytecutError,
+  CONFIG_FILES
+} from "./chunk-TWI2OZJZ.js";
+
+// src/core/fs-safe.ts
+import { randomBytes } from "crypto";
+import { lstat, mkdir, readFile, realpath, rename, unlink, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute, join, relative, sep } from "path";
+function isInside(parent, child) {
+  const rel = relative(parent, child);
+  if (rel === "") return true;
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+async function realpathOfExisting(path) {
+  const rest = [];
+  let current = path;
+  for (; ; ) {
+    try {
+      return join(await realpath(current), ...rest.reverse());
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const parent = dirname(current);
+      if (parent === current) throw error;
+      rest.push(basename(current));
+      current = parent;
+    }
+  }
+}
+var SafeFs = class _SafeFs {
+  constructor(outDir) {
+    this.outDir = outDir;
+  }
+  outDir;
+  /** Validates `outDir` against §6.5 before anything can be written. */
+  static async create(options) {
+    const realOut = await realpathOfExisting(options.outDir);
+    const realRoot = await realpathOfExisting(options.projectRoot);
+    if (realOut === realRoot) {
+      throw new BytecutError(
+        "UNSAFE_OUT_DIR",
+        `Refusing to use the project root as the output folder (${options.outDir}).`
+      );
+    }
+    if (isInside(realOut, realRoot)) {
+      throw new BytecutError(
+        "UNSAFE_OUT_DIR",
+        `The output folder ${options.outDir} contains the project root.`
+      );
+    }
+    for (const dir of options.sourceDirs) {
+      const realDir = await realpathOfExisting(dir);
+      if (realOut === realDir) {
+        throw new BytecutError(
+          "UNSAFE_OUT_DIR",
+          `The output folder ${options.outDir} is itself a source folder.`
+        );
+      }
+      if (isInside(realOut, realDir)) {
+        throw new BytecutError(
+          "UNSAFE_OUT_DIR",
+          `The output folder ${options.outDir} contains the source folder ${dir}.`
+        );
+      }
+    }
+    for (const file of options.sourceFiles) {
+      if (isInside(realOut, await realpathOfExisting(file))) {
+        throw new BytecutError(
+          "UNSAFE_OUT_DIR",
+          `The output folder ${options.outDir} contains the source file ${file}.`
+        );
+      }
+    }
+    return new _SafeFs(realOut);
+  }
+  readSource(absolutePath) {
+    return readFile(absolutePath);
+  }
+  /** Validates a path relative to `outDir` and returns where it lives; touches nothing. */
+  locate(relativePosixPath) {
+    const segments = relativePosixPath.split("/");
+    if (isAbsolute(relativePosixPath) || relativePosixPath.includes("\\") || segments.some((s) => s === "" || s === "." || s === "..")) {
+      throw new BytecutError("UNSAFE_PATH", `Unsafe output path: ${relativePosixPath}`);
+    }
+    const target = join(this.outDir, ...segments);
+    return { target, dir: dirname(target) };
+  }
+  /**
+   * Reads a file we previously wrote (or one that sits where an output would go), or null if
+   * it doesn't exist. Same path checks as writes, and never reads through a symlink.
+   */
+  async readOutput(relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    try {
+      if ((await lstat(target)).isSymbolicLink()) {
+        throw new BytecutError("UNSAFE_PATH", `Refusing to read through symlink: ${target}`);
+      }
+      return await readFile(target);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+  /** `relativePosixPath` is relative to `outDir`. */
+  async writeOutput(relativePosixPath, data) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    await mkdir(dir, { recursive: true });
+    await this.assertInside(await realpath(dir), relativePosixPath);
+    try {
+      if ((await lstat(target)).isSymbolicLink()) {
+        throw new BytecutError("UNSAFE_PATH", `Refusing to write through symlink: ${target}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const temp = join(dir, `.${basename(target)}.${randomBytes(6).toString("hex")}.tmp`);
+    try {
+      await writeFile(temp, data, { flag: "wx" });
+      await rename(temp, target);
+    } catch (error) {
+      await unlink(temp).catch(() => void 0);
+      throw error;
+    }
+  }
+  /**
+   * A path inside `outDir` for a child process (ffmpeg) to write to. The process writes it
+   * itself, so the write boundary is enforced here: the location is validated, never
+   * pre-existing, and only `commitTemp` can turn it into a real output (§6.4).
+   */
+  async reserveTemp(relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    await mkdir(dir, { recursive: true });
+    await this.assertInside(await realpath(dir), relativePosixPath);
+    return join(dir, `.${basename(target)}.${randomBytes(6).toString("hex")}.tmp`);
+  }
+  /** Atomically publishes a file made through `reserveTemp` as `relativePosixPath`. */
+  async commitTemp(tempPath, relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    if (dirname(tempPath) !== dir || !basename(tempPath).endsWith(".tmp")) {
+      throw new BytecutError("UNSAFE_PATH", `Not a reserved temp file for ${relativePosixPath}`);
+    }
+    try {
+      if ((await lstat(target)).isSymbolicLink()) {
+        throw new BytecutError("UNSAFE_PATH", `Refusing to write through symlink: ${target}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    await rename(tempPath, target);
+  }
+  /**
+   * Writes `data` to a reserved temp path and returns it, for handing a file to a child
+   * process (a native scorer). It is never an output: `discardTemp` removes it.
+   */
+  async writeTemp(relativePosixPath, data) {
+    const temp = await this.reserveTemp(relativePosixPath);
+    try {
+      await writeFile(temp, data, { flag: "wx" });
+    } catch (error) {
+      await unlink(temp).catch(() => void 0);
+      throw error;
+    }
+    return temp;
+  }
+  /** Removes a reserved temp file (after a failure or cancel). Never throws. */
+  async discardTemp(tempPath) {
+    if (!isInside(this.outDir, tempPath) || !basename(tempPath).endsWith(".tmp")) return;
+    await unlink(tempPath).catch(() => void 0);
+  }
+  /** Absolute path of an existing output, for reading it with a streaming API. */
+  async outputPath(relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    return target;
+  }
+  async assertInside(resolved, requested) {
+    if (!isInside(this.outDir, resolved)) {
+      throw new BytecutError("UNSAFE_PATH", `Output path escapes the output folder: ${requested}`);
+    }
+  }
+};
+async function writeConfigFile(projectRoot, fileName, content) {
+  if (!CONFIG_FILES.includes(fileName)) {
+    throw new BytecutError("UNSAFE_PATH", `Not a bytecut config file name: ${fileName}`);
+  }
+  const target = join(await realpath(projectRoot), fileName);
+  try {
+    if ((await lstat(target)).isSymbolicLink()) {
+      throw new BytecutError("UNSAFE_PATH", `Refusing to write through symlink: ${fileName}`);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const temp = join(dirname(target), `.${fileName}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    await writeFile(temp, content, { flag: "wx" });
+    await rename(temp, target);
+  } catch (error) {
+    await unlink(temp).catch(() => void 0);
+    throw error;
+  }
+  return target;
+}
+
+export {
+  SafeFs,
+  writeConfigFile
+};

package/dist/chunk-LTWUPQDT.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+// src/core/engines/svg.ts
+import { VERSION, optimize } from "svgo";
+var EMBEDDED_RASTER = /data:image\/(?:png|jpe?g|webp|gif|avif)[^"')\s]*?;base64,([A-Za-z0-9+/=\s]+)/gi;
+var svgoEngine = {
+  version: () => `svgo ${VERSION}`,
+  analyze(text) {
+    let embeddedRasterBytes = 0;
+    let embeddedRasterCount = 0;
+    for (const match of text.matchAll(EMBEDDED_RASTER)) {
+      embeddedRasterCount++;
+      embeddedRasterBytes += match[1].replace(/\s/g, "").length;
+    }
+    let minifiedBytes = null;
+    try {
+      minifiedBytes = Buffer.byteLength(optimize(text, { multipass: true }).data);
+    } catch {
+    }
+    return { minifiedBytes, embeddedRasterBytes, embeddedRasterCount };
+  }
+};
+
+export {
+  svgoEngine
+};

package/dist/chunk-M6ZDSATP.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import {
+  BytecutError
+} from "./chunk-TWI2OZJZ.js";
+
+// src/cli/system.ts
+import { execFile } from "child_process";
+import { readFileSync, statSync } from "fs";
+import { promisify } from "util";
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function readOsReleaseId() {
+  if (process.platform !== "linux") return void 0;
+  try {
+    const text = readFileSync("/etc/os-release", "utf8");
+    return /^ID=("?)([^"\n]+)\1$/m.exec(text)?.[2];
+  } catch {
+    return void 0;
+  }
+}
+var execFileAsync = promisify(execFile);
+var run = async (file, args) => {
+  const { stdout } = await execFileAsync(file, args, { maxBuffer: 16 * 1024 * 1024 });
+  return { stdout };
+};
+function doctorDeps() {
+  return {
+    nodeVersion: process.version,
+    platform: process.platform,
+    env: process.env,
+    osReleaseId: readOsReleaseId(),
+    isFile,
+    run,
+    async loadSharp() {
+      try {
+        const sharp = (await import("sharp")).default;
+        return { version: sharp.versions.sharp ?? "unknown", libvips: sharp.versions.vips };
+      } catch (error) {
+        throw new BytecutError(
+          "SHARP_UNAVAILABLE",
+          error instanceof Error ? error.message.split("\n")[0] : String(error),
+          { cause: error }
+        );
+      }
+    }
+  };
+}
+
+export {
+  isFile,
+  readOsReleaseId,
+  run,
+  doctorDeps
+};