cachelint 0.1.0

package/dist/chunk-MW7BXKPR.js

@@ -0,0 +1,593 @@
+import {
+  RULE_IDS,
+  RULE_SEVERITY_VALUES
+} from "./chunk-4GHSUBAY.js";
+import {
+  ConfigError,
+  SourceError
+} from "./chunk-XKRPGMZT.js";
+
+// src/sources/normalize.ts
+function normalizeText(input) {
+  if (input.length === 0) return "";
+  let s = input;
+  if (s.charCodeAt(0) === 65279) s = s.slice(1);
+  if (s.includes("\r")) {
+    s = s.replace(/\r\n?/g, "\n");
+  }
+  if (/[ \t]+\n|[ \t]+$/.test(s)) {
+    const lines = s.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === void 0) continue;
+      let end = line.length;
+      while (end > 0) {
+        const ch = line.charCodeAt(end - 1);
+        if (ch === 32 || ch === 9) end--;
+        else break;
+      }
+      if (end !== line.length) lines[i] = line.slice(0, end);
+    }
+    s = lines.join("\n");
+  }
+  if (s.length === 0) return "";
+  if (s.endsWith("\n")) {
+    let end = s.length;
+    while (end > 1 && s.charCodeAt(end - 2) === 10) end--;
+    if (end !== s.length) s = s.slice(0, end);
+  } else {
+    s = s + "\n";
+  }
+  return s;
+}
+function hasMixedLineEndings(input) {
+  let hasCRLF = false;
+  let hasBareLF = false;
+  let hasBareCR = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    if (c === 13) {
+      if (i + 1 < input.length && input.charCodeAt(i + 1) === 10) {
+        hasCRLF = true;
+        i++;
+      } else {
+        hasBareCR = true;
+      }
+    } else if (c === 10) {
+      hasBareLF = true;
+    }
+    if (hasCRLF && hasBareLF || hasCRLF && hasBareCR || hasBareCR && hasBareLF) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasBomByte(input) {
+  return input.length > 0 && input.charCodeAt(0) === 65279;
+}
+function toPosixRelative(absPath, projectRoot) {
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const target = absPath.replace(/\\/g, "/");
+  if (root.length === 0) return target;
+  const lowerRoot = root.toLowerCase();
+  const lowerTarget = target.toLowerCase();
+  if (lowerTarget === lowerRoot) return ".";
+  const prefix = lowerRoot.endsWith("/") ? lowerRoot : lowerRoot + "/";
+  if (lowerTarget.startsWith(prefix)) {
+    return target.slice(prefix.length);
+  }
+  return target;
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var nonEmptyString = z.string().min(1, "must not be empty");
+var bundleSchema = z.strictObject({
+  /** Stable bundle name — appears in `cachelint.lock` and in diagnostics. */
+  name: nonEmptyString,
+  /** Files in this bundle, in the exact order they're concatenated for hashing. */
+  files: z.array(nonEmptyString).min(1, "a bundle needs at least one file")
+}).describe("A named, ordered group of files hashed together as one cache prefix.");
+var proSchema = z.strictObject({
+  /** Cap on `--exact` count-tokens API calls per run (default 100). */
+  exact_limit: z.number().int().positive().optional(),
+  /** Provider bug-pattern packs to load, e.g. `["anthropic-2026-q1"]`. */
+  packs: z.array(nonEmptyString).optional()
+}).describe("Pro-tier settings (only consulted when a Pro feature is invoked with a valid license).");
+var configSchema = z.strictObject({
+  /** Optional `$schema` ref so editors can pick up the JSON Schema. Ignored at runtime. */
+  $schema: z.string().optional(),
+  /**
+   * Globs identifying the files cachelint treats as "prompt content files"
+   * for `cachelint lint` (when no explicit paths are given) and for scoping
+   * rule R003 (`unsorted-json-stringify`), which never runs against arbitrary
+   * source — only against files in this list or already in `cachelint.lock`.
+   */
+  prompt_globs: z.array(nonEmptyString).optional(),
+  /** Extra ignore globs, applied on top of the built-in secret-file deny-list. */
+  exclude: z.array(nonEmptyString).optional(),
+  /**
+   * Rule ids to disable globally. An unknown id is rejected (the error lists
+   * the valid ids). Equivalent to setting that rule to `"off"` in `rules`.
+   */
+  disable: z.array(z.enum(RULE_IDS)).optional(),
+  /**
+   * Per-rule severity overrides. `"off"` ≡ listing the rule in `disable`.
+   * Unknown rule ids and unknown severities are both rejected.
+   */
+  rules: z.partialRecord(z.enum(RULE_IDS), z.enum(RULE_SEVERITY_VALUES)).optional(),
+  /** Named multi-file logical bundles for `cachelint hash` / `check`. */
+  bundles: z.array(bundleSchema).optional(),
+  /** Per-file size cap in bytes (default 5 MiB). */
+  max_file_bytes: z.number().int().positive().optional(),
+  /** Cumulative size cap across all resolved files in bytes (default 100 MiB). */
+  max_total_bytes: z.number().int().positive().optional(),
+  /** Pro-tier settings. */
+  pro: proSchema.optional()
+}).describe("cachelint configuration (cachelint.config.json / .yaml / .yml).");
+function defineConfig(config) {
+  return config;
+}
+var JSON_SCHEMA = z.toJSONSchema(configSchema, { target: "draft-2020-12" });
+function configJsonSchema() {
+  return JSON.parse(JSON.stringify(JSON_SCHEMA));
+}
+
+// src/config/load.ts
+import { readFileSync, existsSync, statSync } from "fs";
+import { resolve as pathResolve, isAbsolute, basename, extname } from "path";
+import { parse as parseYaml, YAMLParseError } from "yaml";
+import "zod";
+var CONFIG_FILENAMES = [
+  "cachelint.config.json",
+  "cachelint.config.yaml",
+  "cachelint.config.yml"
+];
+var CODE_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs", ".cts", ".mts"]);
+function loadConfig(opts = {}) {
+  const root = pathResolve(opts.projectRoot ?? process.cwd());
+  const filePath = opts.explicitPath !== void 0 ? resolveExplicit(opts.explicitPath, root) : discover(root);
+  if (filePath === null) {
+    return { config: {}, path: null };
+  }
+  const rel = toPosixRelative(filePath, root);
+  rejectCodeConfig(filePath, rel);
+  let text;
+  try {
+    text = readFileSync(filePath, "utf8");
+  } catch (err) {
+    throw new ConfigError({
+      code: "CFG_UNREADABLE",
+      message: `cannot read config file ${rel}`,
+      file: rel,
+      cause: err
+    });
+  }
+  const data = parseConfigText(text, rel);
+  const config = validate(data, rel);
+  return { config, path: rel };
+}
+function parseConfig(data, sourceLabel = "<config>") {
+  return validate(data, sourceLabel);
+}
+function resolveConfigArg(arg, projectRoot) {
+  if (arg === void 0) {
+    const loaded = loadConfig({ projectRoot });
+    return { config: loaded.config, configPath: loaded.path };
+  }
+  if (typeof arg === "string") {
+    const loaded = loadConfig({ projectRoot, explicitPath: arg });
+    return { config: loaded.config, configPath: loaded.path };
+  }
+  return { config: parseConfig(arg, "<config object>"), configPath: null };
+}
+function resolveExplicit(explicitPath, root) {
+  const abs = isAbsolute(explicitPath) ? explicitPath : pathResolve(root, explicitPath);
+  const rel = toPosixRelative(abs, root);
+  if (!existsSync(abs)) {
+    throw new ConfigError({
+      code: "CFG_NOT_FOUND",
+      message: `config file not found: ${explicitPath}`,
+      file: rel,
+      hint: "Check the --config path, or omit it to auto-discover cachelint.config.{json,yaml,yml}."
+    });
+  }
+  try {
+    if (!statSync(abs).isFile()) {
+      throw new ConfigError({
+        code: "CFG_NOT_FILE",
+        message: `config path is not a regular file: ${explicitPath}`,
+        file: rel
+      });
+    }
+  } catch (err) {
+    if (err instanceof ConfigError) throw err;
+    throw new ConfigError({ code: "CFG_UNREADABLE", message: `cannot stat config file ${rel}`, file: rel, cause: err });
+  }
+  return abs;
+}
+function discover(root) {
+  const found = CONFIG_FILENAMES.map((name) => pathResolve(root, name)).filter((p) => existsSync(p));
+  if (found.length === 0) return null;
+  if (found.length > 1) {
+    throw new ConfigError({
+      code: "CFG_AMBIGUOUS",
+      message: `multiple config files found: ${found.map((p) => basename(p)).join(", ")}`,
+      hint: "Keep exactly one of cachelint.config.{json,yaml,yml}."
+    });
+  }
+  return found[0];
+}
+function rejectCodeConfig(absPath, rel) {
+  const ext = extname(absPath).toLowerCase();
+  if (CODE_CONFIG_EXTENSIONS.has(ext)) {
+    throw new ConfigError({
+      code: "CFG_CODE_NOT_ALLOWED",
+      message: `executable config (${ext}) is not supported: ${rel}`,
+      file: rel,
+      hint: "Use cachelint.config.json or cachelint.config.yaml \u2014 config is data, not code. For dynamic config, call the library API."
+    });
+  }
+}
+function parseConfigText(text, rel) {
+  const isJson = rel.toLowerCase().endsWith(".json");
+  if (isJson) {
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new ConfigError({
+        code: "CFG_PARSE",
+        message: `invalid JSON in ${rel}: ${err instanceof Error ? err.message : String(err)}`,
+        file: rel
+      });
+    }
+  }
+  try {
+    const doc = parseYaml(text);
+    return doc ?? {};
+  } catch (err) {
+    if (err instanceof YAMLParseError) {
+      throw new ConfigError({
+        code: "CFG_PARSE",
+        message: `invalid YAML in ${rel}: ${err.message}`,
+        file: rel
+      });
+    }
+    throw new ConfigError({
+      code: "CFG_PARSE",
+      message: `cannot parse ${rel}: ${err instanceof Error ? err.message : String(err)}`,
+      file: rel
+    });
+  }
+}
+function validate(data, sourceLabel) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new ConfigError({
+      code: "CFG_INVALID",
+      message: `config in ${sourceLabel} must be a mapping/object, got ${describeJsonType(data)}`,
+      file: sourceLabel
+    });
+  }
+  const result = configSchema.safeParse(data);
+  if (!result.success) {
+    throw new ConfigError({
+      code: "CFG_INVALID",
+      message: `invalid config in ${sourceLabel}:
+${formatZodIssues(result.error)}`,
+      file: sourceLabel,
+      hint: "See the published JSON Schema (schema/cachelint.config.schema.json) for the full shape."
+    });
+  }
+  return result.data;
+}
+function describeJsonType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function formatZodIssues(err) {
+  return err.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)";
+    return `  - ${path}: ${issue.message}`;
+  }).join("\n");
+}
+
+// src/sources/resolve.ts
+import { readFileSync as readFileSync2, realpathSync, statSync as statSync2 } from "fs";
+import { resolve as pathResolve2, isAbsolute as isAbsolute2 } from "path";
+import { globSync } from "fs";
+
+// src/sources/hash.ts
+import { createHash } from "crypto";
+function sha256Hex(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function bundleHash(perSourceHashes) {
+  const buf = perSourceHashes.join("\n") + (perSourceHashes.length > 0 ? "\n" : "");
+  return sha256Hex(buf);
+}
+
+// src/sources/resolve.ts
+var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+var BINARY_HEAD_BYTES = 8 * 1024;
+var SECRET_FILE_PATTERNS = [
+  // Env files in any directory: `.env`, `.env.local`, `.env.production`, …
+  { pattern: ".env", kind: "basenameStartsWith" },
+  // Common private-key file extensions.
+  { pattern: ".pem", kind: "endsWith" },
+  { pattern: ".key", kind: "endsWith" },
+  { pattern: ".p8", kind: "endsWith" },
+  { pattern: ".p12", kind: "endsWith" },
+  { pattern: ".pfx", kind: "endsWith" },
+  { pattern: ".cer", kind: "endsWith" },
+  { pattern: ".p7b", kind: "endsWith" },
+  { pattern: ".keystore", kind: "endsWith" },
+  // SSH / GPG / netrc / config files.
+  { pattern: "id_rsa", kind: "basenameStartsWith" },
+  { pattern: "id_ed25519", kind: "basenameStartsWith" },
+  { pattern: "id_ecdsa", kind: "basenameStartsWith" },
+  { pattern: ".ssh/config", kind: "endsWith" },
+  { pattern: ".netrc", kind: "basename" },
+  { pattern: ".npmrc", kind: "basename" },
+  // Common cloud-credentials locations.
+  { pattern: ".aws/credentials", kind: "endsWith" },
+  { pattern: ".aws/config", kind: "endsWith" },
+  { pattern: "gcloud/", kind: "contains" },
+  { pattern: "application_default_credentials.json", kind: "basename" },
+  { pattern: "kubeconfig", kind: "basename" },
+  { pattern: ".docker/config.json", kind: "endsWith" },
+  { pattern: "credentials", kind: "basename" },
+  // GitHub/GH tokens often stored locally.
+  { pattern: "gh_token", kind: "basenameStartsWith" }
+];
+function resolveSources(input) {
+  const root = input.projectRoot ?? process.cwd();
+  const absRoot = pathResolve2(root);
+  const maxFileBytes = input.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+  const maxTotalBytes = input.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+  const extraExclude = input.exclude ?? [];
+  const warnings = [];
+  const sources = [];
+  let cumulative = 0;
+  const expanded = expandPaths(input.paths, absRoot);
+  if (expanded.length === 0) {
+    if (input.required === true) {
+      throw new SourceError({
+        code: "SRC_EMPTY",
+        message: `no files matched: ${input.paths.join(", ")}`,
+        hint: "Check the glob, or mark this source `required: false` if matching nothing is OK."
+      });
+    }
+    warnings.push({
+      code: "GLOB_EMPTY",
+      message: `no files matched: ${input.paths.join(", ")}`
+    });
+    return { sources, warnings };
+  }
+  let nonBinaryCount = 0;
+  for (const absPath of expanded) {
+    const posix = toPosixRelative(absPath, absRoot);
+    const denyMatch = matchesSecretPattern(posix);
+    if (denyMatch !== null) {
+      warnings.push({
+        code: "SKIPPED_SECRET",
+        message: `excluded (matched secret pattern "${denyMatch}")`,
+        path: posix
+      });
+      continue;
+    }
+    if (extraExclude.some((g) => globMatchesPath(g, posix))) {
+      warnings.push({ code: "SKIPPED_EXCLUDED", message: "excluded by config", path: posix });
+      continue;
+    }
+    let st;
+    let realAbs;
+    try {
+      realAbs = realpathSync(absPath);
+      st = statSync2(realAbs);
+    } catch (err) {
+      throw new SourceError({
+        code: "SRC_UNREADABLE",
+        message: `cannot stat ${posix}`,
+        path: posix,
+        cause: err
+      });
+    }
+    if (!isInsideRoot(realAbs, absRoot)) {
+      throw new SourceError({
+        code: "SRC_OUT_OF_ROOT",
+        message: `${posix} resolves outside the project root via symlink`,
+        path: posix,
+        hint: "Symlinks pointing outside the project root are refused \u2014 adjust the link or move the file in."
+      });
+    }
+    if (!st.isFile()) {
+      throw new SourceError({
+        code: "SRC_NOT_FILE",
+        message: `${posix} is not a regular file (device / socket / fifo)`,
+        path: posix
+      });
+    }
+    if (st.size > maxFileBytes) {
+      throw new SourceError({
+        code: "SRC_TOO_LARGE",
+        message: `${posix} is ${st.size} bytes; exceeds maxFileBytes ${maxFileBytes}`,
+        path: posix,
+        hint: "Raise maxFileBytes in cachelint.config, or split the source."
+      });
+    }
+    cumulative += st.size;
+    if (cumulative > maxTotalBytes) {
+      throw new SourceError({
+        code: "SRC_TOTAL_TOO_LARGE",
+        message: `cumulative bytes ${cumulative} would exceed maxTotalBytes ${maxTotalBytes}`,
+        hint: "Raise maxTotalBytes in cachelint.config, or scope the glob more tightly."
+      });
+    }
+    let bytes;
+    try {
+      bytes = readFileSync2(realAbs);
+    } catch (err) {
+      throw new SourceError({
+        code: "SRC_UNREADABLE",
+        message: `cannot read ${posix}`,
+        path: posix,
+        cause: err
+      });
+    }
+    if (bytes.length > maxFileBytes) {
+      throw new SourceError({
+        code: "SRC_TOO_LARGE",
+        message: `${posix} read as ${bytes.length} bytes; exceeds maxFileBytes ${maxFileBytes}`,
+        path: posix,
+        hint: "Raise maxFileBytes in cachelint.config, or split the source. (statSync under-reported its size \u2014 this can happen with /proc-style files.)"
+      });
+    }
+    if (bytes.length !== st.size) cumulative += bytes.length - st.size;
+    if (cumulative > maxTotalBytes) {
+      throw new SourceError({
+        code: "SRC_TOTAL_TOO_LARGE",
+        message: `cumulative bytes ${cumulative} would exceed maxTotalBytes ${maxTotalBytes}`,
+        hint: "Raise maxTotalBytes in cachelint.config, or scope the glob more tightly."
+      });
+    }
+    if (looksBinary(bytes)) {
+      warnings.push({ code: "SKIPPED_BINARY", message: "skipped: binary content", path: posix });
+      continue;
+    }
+    let raw;
+    try {
+      raw = bytes.toString("utf8");
+    } catch (err) {
+      warnings.push({ code: "SKIPPED_NON_UTF8", message: "skipped: not valid UTF-8", path: posix });
+      continue;
+    }
+    const normalized = normalizeText(raw);
+    const sha = sha256Hex(normalized);
+    sources.push({
+      name: input.name ?? posix,
+      path: posix,
+      raw,
+      normalized,
+      sha256: sha,
+      bytes: st.size,
+      bomByte: hasBomByte(raw),
+      mixedLineEndings: hasMixedLineEndings(raw)
+    });
+    nonBinaryCount++;
+  }
+  if (input.required === true && nonBinaryCount === 0) {
+    throw new SourceError({
+      code: "SRC_NO_TEXT",
+      message: `no text files resolved from required source ${input.paths.join(", ")} (all matches were binary or excluded)`
+    });
+  }
+  return { sources, warnings };
+}
+function expandPaths(paths, absRoot) {
+  const all = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    if (isGlob(p)) {
+      const matches = globSync(p, { cwd: absRoot });
+      for (const m of matches) {
+        all.add(isAbsolute2(m) ? m : pathResolve2(absRoot, m));
+      }
+    } else {
+      const abs = isAbsolute2(p) ? p : pathResolve2(absRoot, p);
+      all.add(abs);
+    }
+  }
+  return [...all].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function isGlob(s) {
+  return /[*?[\]{}]/.test(s);
+}
+function globMatchesPath(pattern, path) {
+  let re = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i] ?? "";
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+      } else {
+        re += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i++;
+    } else if (c === "{") {
+      const end = pattern.indexOf("}", i);
+      if (end === -1) {
+        re += "\\{";
+        i++;
+        continue;
+      }
+      const alts = pattern.slice(i + 1, end).split(",").map((s) => s.replace(/[.+^$()|\\]/g, "\\$&"));
+      re += `(?:${alts.join("|")})`;
+      i = end + 1;
+    } else if (/[.+^$()|\\]/.test(c)) {
+      re += "\\" + c;
+      i++;
+    } else {
+      re += c;
+      i++;
+    }
+  }
+  try {
+    return new RegExp("^" + re + "$").test(path);
+  } catch {
+    return false;
+  }
+}
+function isInsideRoot(target, root) {
+  const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+  const t = norm(target);
+  const r = norm(root);
+  return t === r || t.startsWith(r + "/");
+}
+function matchesSecretPattern(posixPath) {
+  const lower = posixPath.toLowerCase();
+  const basename2 = lower.split("/").pop() ?? "";
+  for (const { pattern, kind } of SECRET_FILE_PATTERNS) {
+    const p = pattern.toLowerCase();
+    switch (kind) {
+      case "endsWith":
+        if (lower.endsWith(p)) return pattern;
+        break;
+      case "basename":
+        if (basename2 === p) return pattern;
+        break;
+      case "basenameStartsWith":
+        if (basename2.startsWith(p)) return pattern;
+        break;
+      case "contains":
+        if (lower.includes(p)) return pattern;
+        break;
+    }
+  }
+  return null;
+}
+function looksBinary(buf) {
+  const limit = Math.min(buf.length, BINARY_HEAD_BYTES);
+  for (let i = 0; i < limit; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+
+export {
+  toPosixRelative,
+  configSchema,
+  defineConfig,
+  configJsonSchema,
+  CONFIG_FILENAMES,
+  loadConfig,
+  parseConfig,
+  resolveConfigArg,
+  bundleHash,
+  resolveSources
+};

package/dist/chunk-O7ZE6CFI.js

@@ -0,0 +1,32 @@
+// src/cost/pricing.ts
+var PRICING_TABLE_VERSION = 1;
+var PRICING_AS_OF = "2026-06";
+var REFERENCE_MODEL = "claude-sonnet-4-6";
+var TABLE = Object.freeze([
+  { model: "claude-opus-4-8", baseInputPerMTok: 5, cacheReadPerMTok: 0.5, minCacheablePrefixTokens: 4096 },
+  { model: "claude-opus-4-7", baseInputPerMTok: 5, cacheReadPerMTok: 0.5, minCacheablePrefixTokens: 4096 },
+  { model: "claude-opus-4-6", baseInputPerMTok: 5, cacheReadPerMTok: 0.5, minCacheablePrefixTokens: 4096 },
+  { model: "claude-sonnet-4-6", baseInputPerMTok: 3, cacheReadPerMTok: 0.3, minCacheablePrefixTokens: 2048 },
+  { model: "claude-haiku-4-5", baseInputPerMTok: 1, cacheReadPerMTok: 0.1, minCacheablePrefixTokens: 4096 },
+  { model: "claude-fable-5", baseInputPerMTok: 10, cacheReadPerMTok: 1, minCacheablePrefixTokens: 2048 }
+]);
+function getModelPricing(model) {
+  return TABLE.find((p) => p.model === model) ?? null;
+}
+function referencePricing() {
+  const p = getModelPricing(REFERENCE_MODEL);
+  if (p === null) throw new Error(`cachelint: reference model ${REFERENCE_MODEL} missing from pricing table`);
+  return p;
+}
+function wastePerTokenUsd(p) {
+  return (p.baseInputPerMTok - p.cacheReadPerMTok) / 1e6;
+}
+
+export {
+  PRICING_TABLE_VERSION,
+  PRICING_AS_OF,
+  REFERENCE_MODEL,
+  getModelPricing,
+  referencePricing,
+  wastePerTokenUsd
+};

package/dist/chunk-SQ4IAMTX.js

@@ -0,0 +1,65 @@
+import {
+  DEFAULT_LOCKFILE_NAME,
+  computeBundles,
+  makeLockfile,
+  writeLockfileAtomic
+} from "./chunk-BUZCVKMZ.js";
+import {
+  resolveConfigArg,
+  toPosixRelative
+} from "./chunk-MW7BXKPR.js";
+import {
+  CACHELINT_VERSION
+} from "./chunk-WPJYUQMU.js";
+import {
+  redactSecrets
+} from "./chunk-XKRPGMZT.js";
+
+// src/commands/hash.ts
+import { resolve as pathResolve } from "path";
+function hash(args = {}) {
+  const root = pathResolve(args.projectRoot ?? process.cwd());
+  const { config, configPath } = resolveConfigArg(args.config, root);
+  const { bundles, warnings } = computeBundles({
+    ...args.paths !== void 0 ? { paths: args.paths } : {},
+    config,
+    projectRoot: root
+  });
+  const lockfile = makeLockfile(bundles);
+  const lockPath = pathResolve(root, args.out ?? DEFAULT_LOCKFILE_NAME);
+  const text = writeLockfileAtomic(lockPath, lockfile);
+  return { lockfile, text, path: lockPath, configPath, warnings, bundleCount: bundles.length };
+}
+function renderHashHuman(r, projectRoot = process.cwd()) {
+  const lockDisplay = toPosixRelative(r.path, pathResolve(projectRoot));
+  const lines = [];
+  for (const w of r.warnings) lines.push(`note  ${w.path ? w.path + ": " : ""}${w.message}`);
+  lines.push(`cachelint: wrote ${r.bundleCount} bundle${r.bundleCount === 1 ? "" : "s"} to ${lockDisplay}`);
+  for (const b of r.lockfile.bundles) {
+    const files = b.files.length === 1 ? b.files[0].path : `${b.files.length} files`;
+    lines.push(`  ${b.name}  ${b.stablePrefixHash.slice(0, 12)}  (${files})`);
+  }
+  return redactSecrets(lines.join("\n"));
+}
+function renderHashJson(r, projectRoot = process.cwd()) {
+  return redactSecrets(
+    JSON.stringify(
+      {
+        version: CACHELINT_VERSION,
+        configPath: r.configPath,
+        lockfilePath: toPosixRelative(r.path, pathResolve(projectRoot)),
+        bundleCount: r.bundleCount,
+        bundles: r.lockfile.bundles,
+        warnings: r.warnings
+      },
+      null,
+      2
+    )
+  ) + "\n";
+}
+
+export {
+  hash,
+  renderHashHuman,
+  renderHashJson
+};