livelocale 0.12.1 → 1.0.0

package/dist/codemod/index.js

@@ -297,8 +297,8 @@ var init_transform = __esm({
 });
 
 // src/codemod/index.ts
-import * as fs14 from "fs";
-import * as path21 from "path";
+import * as fs15 from "fs";
+import * as path22 from "path";
 import * as net from "net";
 
 // src/server/module-dir.ts
@@ -746,7 +746,7 @@ function isShareManifest(value) {
   const layout = own2(value, "layout");
   const locales = own2(value, "locales");
   const sourceLocale = own2(value, "sourceLocale");
-  return own2(value, "format") === SHARE_MANIFEST_FORMAT && (repo === void 0 || typeof repo === "string" && isValidRepoSlug(repo)) && isNullOr(own2(value, "defaultBranch"), isValidBranchName) && isNullOr(own2(value, "branch"), isValidBranchName) && isNullOr(own2(value, "base"), (base) => BASE_SHA_RE2.test(base)) && typeof own2(value, "localesPath") === "string" && (layout === "flat" || layout === "namespaced") && isArrayOf(locales, isLocaleCode) && typeof sourceLocale === "string" && locales.includes(sourceLocale) && isNullOr(own2(value, "basePath"), (path22) => path22.startsWith("/") && path22.endsWith("/")) && isArrayOf(own2(value, "codeKeys"), isString);
+  return own2(value, "format") === SHARE_MANIFEST_FORMAT && (repo === void 0 || typeof repo === "string" && isValidRepoSlug(repo)) && isNullOr(own2(value, "defaultBranch"), isValidBranchName) && isNullOr(own2(value, "branch"), isValidBranchName) && isNullOr(own2(value, "base"), (base) => BASE_SHA_RE2.test(base)) && typeof own2(value, "localesPath") === "string" && (layout === "flat" || layout === "namespaced") && isArrayOf(locales, isLocaleCode) && typeof sourceLocale === "string" && locales.includes(sourceLocale) && isNullOr(own2(value, "basePath"), (path23) => path23.startsWith("/") && path23.endsWith("/")) && isArrayOf(own2(value, "codeKeys"), isString);
 }
 
 // src/codemod/doctor.ts
@@ -2394,6 +2394,28 @@ function listLocales(localesDir) {
   }
   return Array.from(locales).sort();
 }
+function hasLocaleFile(localesDir, locale) {
+  const dir = path8.join(localesDir, locale);
+  if (fs6.existsSync(dir) && fs6.statSync(dir).isDirectory()) {
+    return fs6.readdirSync(dir).some((file) => file.endsWith(".json"));
+  }
+  return fs6.existsSync(path8.join(localesDir, `${locale}.json`));
+}
+function noLocaleFilesError(localesDir) {
+  const skipped = [];
+  for (const item of fs6.readdirSync(localesDir, { withFileTypes: true })) {
+    if (item.isDirectory() && !item.name.startsWith(".") && !LOCALE_RE.test(item.name)) {
+      skipped.push(`${item.name}/`);
+    } else if (item.isFile() && item.name.endsWith(".json")) {
+      if (!LOCALE_RE.test(path8.basename(item.name, ".json"))) skipped.push(item.name);
+    }
+  }
+  skipped.sort();
+  const hint = skipped.length === 0 ? "" : ` Skipped ${skipped.slice(0, 3).join(", ")}${skipped.length > 3 ? ", ..." : ""}: a locale name looks like en, ar or pt-BR.`;
+  return new Error(
+    `No locale files found in ${localesDir}. Point --locales at the folder with en.json, ar.json, ...${hint}`
+  );
+}
 function flatten(obj, prefix, file, data) {
   if (!obj || typeof obj !== "object" || Array.isArray(obj)) return;
   for (const [key, value] of Object.entries(obj)) {
@@ -2470,6 +2492,9 @@ async function runCheck(options) {
     throw new Error(`Locales directory not found: ${localesDir}`);
   }
   const locales = listLocales(localesDir);
+  if (!locales.some((locale) => hasLocaleFile(localesDir, locale))) {
+    throw noLocaleFilesError(localesDir);
+  }
   const data = new Map(locales.map((l) => [l, readLocale(localesDir, l, projectDir, issues)]));
   const sourceLocale = options.sourceLocale ?? (locales.includes("en") ? "en" : locales[0] ?? null);
   if (sourceLocale && !data.has(sourceLocale)) {
@@ -2664,44 +2689,181 @@ function formatCheckReport(report, limit = 25) {
   return lines.join("\n");
 }
 
-// src/codemod/check-cli.ts
-function parseCheckArgs(argv) {
-  const args = {
-    dir: ".",
-    unused: true,
-    strict: false,
-    json: false,
-    hardcoded: false,
-    allow: []
-  };
+// src/codemod/cli-args.ts
+var UsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
+var USAGE_EXIT_CODE = 2;
+var GLOBAL_SHORT = /* @__PURE__ */ new Set(["-h", "-v"]);
+function knownOptions(spec) {
+  return [...spec.values ?? [], ...spec.repeatable ?? [], ...spec.flags ?? []];
+}
+function editDistance(a, b) {
+  const d = Array.from(
+    { length: a.length + 1 },
+    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+      }
+    }
+  }
+  return d[a.length][b.length];
+}
+function suggestOption(arg, known) {
+  const name = arg.replace(/^-+/, "");
+  let best;
+  let bestDistance = Infinity;
+  for (const option of known) {
+    const distance = editDistance(name, option.replace(/^-+/, ""));
+    if (distance < bestDistance) {
+      best = option;
+      bestDistance = distance;
+    }
+  }
+  return bestDistance <= 2 && bestDistance < name.length / 2 ? best : void 0;
+}
+function unknownOption(spec, arg) {
+  const known = knownOptions(spec);
+  const head = `Unknown option ${arg} for livelocale ${spec.command}.`;
+  const eq = arg.indexOf("=");
+  if (eq > 0 && known.includes(arg.slice(0, eq))) {
+    return new UsageError(
+      `${head} Put a space before the value: ${arg.slice(0, eq)} ${arg.slice(eq + 1)}`
+    );
+  }
+  const suggestion = suggestOption(arg, known);
+  return new UsageError(
+    suggestion ? `${head} Did you mean ${suggestion}?` : `${head} Run livelocale --help to see its options.`
+  );
+}
+function parseCommandArgs(spec, argv) {
+  const parsed = { values: {}, lists: {}, flags: /* @__PURE__ */ new Set(), positionals: [], rest: [] };
+  const values = new Set(spec.values ?? []);
+  const repeatable = new Set(spec.repeatable ?? []);
+  const flags = new Set(spec.flags ?? []);
+  const maxPositionals = spec.positionals ?? 0;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
-    if (arg === "--dir") {
-      args.dir = argv[++i] || ".";
-    } else if (arg === "--locales") {
-      args.localesPath = argv[++i];
-    } else if (arg === "--source") {
-      args.sourceLocale = argv[++i];
-    } else if (arg === "--no-unused") {
-      args.unused = false;
-    } else if (arg === "--strict") {
-      args.strict = true;
-    } else if (arg === "--json") {
-      args.json = true;
-    } else if (arg === "--hardcoded") {
-      args.hardcoded = true;
-    } else if (arg === "--allow") {
-      const word = argv[++i];
-      if (!word || word.startsWith("--")) throw new Error("--allow needs a word.");
-      args.allow.push(word);
-    } else if (arg && !arg.startsWith("--")) {
-      args.dir = arg;
+    if (arg === "--") {
+      if (!spec.rest) throw new UsageError(`livelocale ${spec.command} takes nothing after --.`);
+      parsed.rest = argv.slice(i + 1);
+      break;
+    }
+    if (values.has(arg) || repeatable.has(arg)) {
+      const value = argv[i + 1];
+      if (value === void 0 || value.startsWith("--") || GLOBAL_SHORT.has(value)) {
+        throw new UsageError(`${arg} needs a value.`);
+      }
+      i++;
+      if (repeatable.has(arg)) (parsed.lists[arg] ??= []).push(value);
+      else parsed.values[arg] = value;
+    } else if (flags.has(arg)) {
+      parsed.flags.add(arg);
+    } else if (arg.startsWith("-") && arg !== "-") {
+      throw unknownOption(spec, arg);
+    } else if (parsed.positionals.length < maxPositionals) {
+      parsed.positionals.push(arg);
+    } else {
+      throw new UsageError(`Unexpected argument "${arg}" for livelocale ${spec.command}.`);
     }
   }
+  return parsed;
+}
+function findGlobalOption(args, spec) {
+  const takesValue = /* @__PURE__ */ new Set([...spec?.values ?? [], ...spec?.repeatable ?? []]);
+  let found;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") break;
+    if (takesValue.has(arg)) {
+      if (args[i + 1] !== "--") i++;
+    } else if (arg === "--help" || arg === "-h") return "help";
+    else if (arg === "--version" || arg === "-v") found = "version";
+  }
+  return found;
+}
+function splitList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function folderArg(parsed) {
+  const plain = parsed.positionals[0];
+  const flag = parsed.values["--dir"];
+  if (plain !== void 0 && flag !== void 0) {
+    throw new UsageError(`Pass the folder once: "${plain}" or --dir ${flag}, not both.`);
+  }
+  return plain ?? flag ?? ".";
+}
+
+// src/codemod/command-specs.ts
+var COMMAND_SPECS = {
+  migrate: {
+    command: "migrate",
+    values: ["--dir", "--exclude"],
+    flags: ["--dry-run"],
+    positionals: 1
+  },
+  init: {
+    command: "init",
+    values: ["--dir", "--locales", "--source", "--branches"],
+    flags: ["--share", "--overwrite"],
+    positionals: 1
+  },
+  studio: { command: "studio", values: ["--port", "--app"] },
+  doctor: {
+    command: "doctor",
+    values: ["--dir", "--locales", "--app", "--token"],
+    flags: ["--share"],
+    positionals: 1
+  },
+  check: {
+    command: "check",
+    values: ["--dir", "--locales", "--source"],
+    repeatable: ["--allow"],
+    flags: ["--no-unused", "--strict", "--hardcoded", "--json"],
+    positionals: 1
+  },
+  // `pack` and `build` share one set; checkPackArgs and checkBuildArgs reject the other's options
+  // with a message that names the right command.
+  pack: {
+    command: "pack",
+    values: ["--dir", "--locales", "--source", "--base", "--out"],
+    flags: ["--expose-repo", "--no-inject", "--preview"],
+    positionals: Infinity,
+    rest: true
+  },
+  apply: {
+    command: "apply",
+    values: ["--dir", "--locales", "--source", "--branches"],
+    flags: ["--clipboard", "--pr", "--force", "--dry-run", "--github-event"],
+    positionals: Infinity
+  }
+};
+
+// src/codemod/check-cli.ts
+function parseCheckArgs(argv) {
+  const parsed = parseCommandArgs(COMMAND_SPECS.check, argv);
+  const args = {
+    dir: folderArg(parsed),
+    unused: !parsed.flags.has("--no-unused"),
+    strict: parsed.flags.has("--strict"),
+    json: parsed.flags.has("--json"),
+    hardcoded: parsed.flags.has("--hardcoded"),
+    allow: parsed.lists["--allow"] ?? []
+  };
+  if (parsed.values["--locales"] !== void 0) args.localesPath = parsed.values["--locales"];
+  if (parsed.values["--source"] !== void 0) args.sourceLocale = parsed.values["--source"];
   return args;
 }
 function checkExitCode(report) {
-  if (report.setupProblems && report.setupProblems.length > 0) return 2;
+  if (report.setupProblems && report.setupProblems.length > 0) return CHECK_COULD_NOT_RUN;
   return hasCheckFailures(report) ? 1 : 0;
 }
 function checkSummaryLines(report) {
@@ -2714,6 +2876,22 @@ function checkSummaryLines(report) {
     warns > 0 ? `\u2705 No problems, ${warns} warning(s) worth a look.` : `\u2705 Translations look good.`
   ];
 }
+var CHECK_COULD_NOT_RUN = 2;
+function checkErrorReport(error, localesDir) {
+  return {
+    error,
+    localesDir: localesDir ?? "",
+    sourceLocale: null,
+    locales: [],
+    codeKeyCount: 0,
+    issues: [],
+    setupProblems: [error]
+  };
+}
+function withCheckError(report) {
+  const problems = report.setupProblems ?? [];
+  return problems.length > 0 ? { ...report, error: problems.join(" ") } : report;
+}
 
 // src/server/pack.ts
 import { spawn } from "child_process";
@@ -2722,8 +2900,8 @@ import * as path11 from "path";
 
 // src/core/page-path.ts
 var NON_ASCII_ESCAPES = /(?:%[89A-Fa-f][0-9A-Fa-f])+/g;
-function readablePath(path22) {
-  return path22.replace(NON_ASCII_ESCAPES, (run3) => {
+function readablePath(path23) {
+  return path23.replace(NON_ASCII_ESCAPES, (run3) => {
     try {
       return decodeURIComponent(run3);
     } catch {
@@ -2736,16 +2914,16 @@ function readablePath(path22) {
 import { execFile } from "child_process";
 import { readFileSync as readFileSync5 } from "fs";
 import * as path9 from "path";
-var runGit = (args, cwd) => new Promise((resolve18) => {
+var runGit = (args, cwd) => new Promise((resolve19) => {
   try {
     execFile(
       "git",
       args,
       { cwd, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } },
-      (error, stdout) => resolve18(error ? null : String(stdout).trim())
+      (error, stdout) => resolve19(error ? null : String(stdout).trim())
     );
   } catch {
-    resolve18(null);
+    resolve19(null);
   }
 });
 var SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/i;
@@ -3046,8 +3224,8 @@ var NO_REPO_WARNING = "exposeRepo is on but no GitHub repository was found; the
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function toPosix(relative11) {
-  return relative11.split(path11.sep).join("/") || ".";
+function toPosix(relative12) {
+  return relative12.split(path11.sep).join("/") || ".";
 }
 function isInside(parent, child) {
   const rel = path11.relative(parent, child);
@@ -3303,52 +3481,27 @@ async function packOutput(options) {
     warnings
   };
 }
-var VALUE_OPTIONS = {
-  "--dir": "dir",
-  "--locales": "locales",
-  "--source": "source",
-  "--base": "base",
-  "--out": "out"
-};
-function parseShareArgs(argv) {
-  const args = {
-    positional: [],
-    dir: ".",
-    locales: void 0,
-    source: void 0,
-    base: void 0,
-    out: void 0,
-    exposeRepo: false,
-    inject: true,
-    preview: false,
-    command: []
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--") {
-      args.command = argv.slice(i + 1);
-      break;
-    }
-    if (Object.prototype.hasOwnProperty.call(VALUE_OPTIONS, arg)) {
-      const value = argv[i + 1];
-      if (value === void 0 || value.startsWith("--")) {
-        throw new PackError("USAGE", `${arg} needs a value.`);
-      }
-      args[VALUE_OPTIONS[arg]] = value;
-      i++;
-    } else if (arg === "--expose-repo") {
-      args.exposeRepo = true;
-    } else if (arg === "--no-inject") {
-      args.inject = false;
-    } else if (arg === "--preview") {
-      args.preview = true;
-    } else if (arg.startsWith("-") && arg !== "-") {
-      throw new PackError("USAGE", `Unknown option "${arg}".`);
-    } else {
-      args.positional.push(arg);
-    }
+function parseShareArgs(argv, command = "pack") {
+  let parsed;
+  try {
+    parsed = parseCommandArgs({ ...COMMAND_SPECS.pack, command }, argv);
+  } catch (err) {
+    if (err instanceof UsageError) throw new PackError("USAGE", err.message);
+    throw err;
   }
-  return args;
+  const { values, flags } = parsed;
+  return {
+    positional: parsed.positionals,
+    dir: values["--dir"] ?? ".",
+    locales: values["--locales"],
+    source: values["--source"],
+    base: values["--base"],
+    out: values["--out"],
+    exposeRepo: flags.has("--expose-repo"),
+    inject: !flags.has("--no-inject"),
+    preview: flags.has("--preview"),
+    command: parsed.rest
+  };
 }
 var PACK_USAGE = "Usage: livelocale pack <outDir> [options]";
 var BUILD_USAGE = "Usage: livelocale build [--preview] -- <your build command>";
@@ -3418,7 +3571,7 @@ function quoteWindowsArg(arg) {
   }
   return out + "\\".repeat(backslashes * 2) + '"';
 }
-var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve18, reject2) => {
+var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve19, reject2) => {
   const child = process.platform === "win32" ? spawn([command, ...args].map(quoteWindowsArg).join(" "), {
     cwd,
     env,
@@ -3426,10 +3579,10 @@ var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve18, reje
     shell: true
   }) : spawn(command, args, { cwd, env, stdio: "inherit" });
   child.on("error", (error) => {
-    if (error.code === "ENOENT") resolve18(127);
+    if (error.code === "ENOENT") resolve19(127);
     else reject2(error);
   });
-  child.on("close", (code) => resolve18(code ?? 1));
+  child.on("close", (code) => resolve19(code ?? 1));
 });
 var NEXT_PREVIEW_WARNING = "Next.js pages have no watermarks without --preview; the Studio will open but nothing is editable.";
 var NEXT_GITIGNORE_WARNING = "Add public/livelocale/ to .gitignore; it is generated on every build.";
@@ -3878,8 +4031,8 @@ function createGitHubRest(config) {
     "X-GitHub-Api-Version": "2022-11-28",
     ...hasBody ? { "Content-Type": "application/json" } : {}
   });
-  async function api(method, path22, options = {}) {
-    const url = new URL(`${apiBase}/repos/${repo}${path22}`);
+  async function api(method, path23, options = {}) {
+    const url = new URL(`${apiBase}/repos/${repo}${path23}`);
     for (const [k, v] of Object.entries(options.query ?? {})) url.searchParams.set(k, v);
     const response = await fetchImpl(url.toString(), {
       method,
@@ -3896,14 +4049,14 @@ function createGitHubRest(config) {
       const detail = data?.message || "request failed";
       const hint = /not accessible by/i.test(detail) ? ' The token lacks a permission: give it "Contents" and "Pull requests" with "Read and write" on this repository.' : "";
       throw new GitHubApiError(
-        `GitHub API ${response.status} on ${method} ${path22}: ${detail}.${hint}`,
+        `GitHub API ${response.status} on ${method} ${path23}: ${detail}.${hint}`,
         response.status
       );
     }
     return { status: response.status, data };
   }
-  async function probeStatus(method, path22, body) {
-    const response = await fetchImpl(`${apiBase}/repos/${repo}${path22}`, {
+  async function probeStatus(method, path23, body) {
+    const response = await fetchImpl(`${apiBase}/repos/${repo}${path23}`, {
       method,
       headers: headers(body !== void 0),
       body: body !== void 0 ? JSON.stringify(body) : void 0
@@ -4765,7 +4918,7 @@ function clipboardCommands(platform) {
 }
 var TOO_LARGE = /* @__PURE__ */ Symbol("too large");
 function run(execFileImpl, [command, args]) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     try {
       execFileImpl(
         command,
@@ -4773,12 +4926,12 @@ function run(execFileImpl, [command, args]) {
         { encoding: "utf8", windowsHide: true, maxBuffer: MAX_APPLY_INPUT_BYTES + 1 },
         (error, stdout) => {
           const code = error?.code;
-          if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") resolve18(TOO_LARGE);
-          else resolve18(error ? null : String(stdout));
+          if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") resolve19(TOO_LARGE);
+          else resolve19(error ? null : String(stdout));
         }
       );
     } catch {
-      resolve18(null);
+      resolve19(null);
     }
   });
 }
@@ -5373,30 +5526,30 @@ var GITHUB_REMOTE_RE = /github\.com[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/;
 var defaultGit = (args, cwd, opts) => {
   const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
   if (opts?.inherit) {
-    return new Promise((resolve18, reject2) => {
+    return new Promise((resolve19, reject2) => {
       const child = spawn2("git", args, { cwd, env, stdio: "inherit", windowsHide: true });
       child.on("error", reject2);
       child.on(
         "close",
-        (code) => code === 0 ? resolve18("") : reject2(new Error(`git ${args[0]} failed (exit ${code}).`))
+        (code) => code === 0 ? resolve19("") : reject2(new Error(`git ${args[0]} failed (exit ${code}).`))
       );
     });
   }
-  return new Promise((resolve18, reject2) => {
+  return new Promise((resolve19, reject2) => {
     execFile4(
       "git",
       args,
       { cwd, env, windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
-      (error, stdout) => error ? reject2(error) : resolve18(String(stdout))
+      (error, stdout) => error ? reject2(error) : resolve19(String(stdout))
     );
   });
 };
-var defaultGh = (args, cwd) => new Promise((resolve18, reject2) => {
+var defaultGh = (args, cwd) => new Promise((resolve19, reject2) => {
   execFile4(
     "gh",
     args,
     { cwd, windowsHide: true },
-    (error, stdout, stderr) => error ? reject2(Object.assign(error, { stderr: String(stderr) })) : resolve18(String(stdout))
+    (error, stdout, stderr) => error ? reject2(Object.assign(error, { stderr: String(stderr) })) : resolve19(String(stdout))
   );
 });
 function utcStamp(date) {
@@ -5597,70 +5750,42 @@ async function runLocalApply(options) {
 }
 
 // src/codemod/apply/cli.ts
-var VALUE_OPTIONS2 = { "--dir": "dir", "--locales": "locales", "--source": "source" };
-var FLAG_OPTIONS = {
-  "--clipboard": "clipboard",
-  "--pr": "pr",
-  "--force": "force",
-  "--dry-run": "dryRun",
-  "--github-event": "githubEvent"
-};
 function parseApplyArgs(argv) {
+  const parsed = parseCommandArgs(COMMAND_SPECS.apply, argv);
+  if (parsed.positionals.length > 1) throw new UsageError('Pass one change link, file or "-".');
+  const branches = parsed.values["--branches"];
   const args = {
-    input: void 0,
-    clipboard: false,
-    pr: false,
-    force: false,
-    dryRun: false,
-    dir: ".",
-    locales: void 0,
-    source: void 0,
-    githubEvent: false,
-    branches: void 0
+    input: parsed.positionals[0],
+    clipboard: parsed.flags.has("--clipboard"),
+    pr: parsed.flags.has("--pr"),
+    force: parsed.flags.has("--force"),
+    dryRun: parsed.flags.has("--dry-run"),
+    dir: parsed.values["--dir"] ?? ".",
+    locales: parsed.values["--locales"],
+    source: parsed.values["--source"],
+    githubEvent: parsed.flags.has("--github-event"),
+    branches: branches === void 0 ? void 0 : splitList(branches)
   };
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--branches") {
-      const value = argv[i + 1];
-      if (value === void 0 || value.startsWith("--")) {
-        throw new ApplyInputError(`${arg} needs a value.`);
-      }
-      args.branches = value.split(",").map((branch) => branch.trim()).filter(Boolean);
-      i++;
-    } else if (Object.prototype.hasOwnProperty.call(VALUE_OPTIONS2, arg)) {
-      const value = argv[i + 1];
-      if (value === void 0 || value.startsWith("--")) {
-        throw new ApplyInputError(`${arg} needs a value.`);
-      }
-      args[VALUE_OPTIONS2[arg]] = value;
-      i++;
-    } else if (Object.prototype.hasOwnProperty.call(FLAG_OPTIONS, arg)) {
-      args[FLAG_OPTIONS[arg]] = true;
-    } else if (arg.startsWith("-") && arg !== "-") {
-      throw new ApplyInputError(`Unknown option "${arg}".`);
-    } else if (args.input !== void 0) {
-      throw new ApplyInputError('Pass one change link, file or "-".');
-    } else {
-      args.input = arg;
-    }
-  }
   if (args.clipboard && args.input !== void 0) {
-    throw new ApplyInputError("Pass the link or --clipboard, not both.");
+    throw new UsageError("Pass the link or --clipboard, not both.");
+  }
+  if (args.branches !== void 0 && !args.githubEvent) {
+    throw new UsageError("--branches only works with --github-event.");
   }
   if (args.githubEvent) {
     if (args.force) {
-      throw new ApplyInputError(
+      throw new UsageError(
         "--force is not allowed with --github-event; a maintainer comments `/livelocale apply --force`."
       );
     }
     if (args.input !== void 0) {
-      throw new ApplyInputError(
-        "--github-event reads the link from the event file; do not pass one."
-      );
+      throw new UsageError("--github-event reads the link from the event file; do not pass one.");
     }
     if (args.locales === void 0 || args.source === void 0) {
-      throw new ApplyInputError("--github-event needs --locales and --source.");
+      throw new UsageError("--github-event needs --locales and --source.");
     }
+  } else if (!args.clipboard && (args.input === void 0 || args.input === "")) {
+    throw new UsageError(NO_INPUT_MESSAGE);
   }
   return args;
 }
@@ -5694,7 +5819,7 @@ async function runApplyCommand(argv) {
     process.exitCode = result.exitCode;
   } catch (err) {
     console.error(`\u274C ${err instanceof Error ? err.message : String(err)}`);
-    process.exitCode = 1;
+    process.exitCode = err instanceof UsageError ? USAGE_EXIT_CODE : 1;
   }
 }
 
@@ -5799,37 +5924,6 @@ function renderWorkflow(o) {
     ""
   ].join("\n");
 }
-function parseInitShareArgs(argv) {
-  const args = {
-    dir: ".",
-    localesPath: void 0,
-    sourceLocale: void 0,
-    branches: void 0,
-    overwrite: false
-  };
-  const valueAt = (i) => {
-    const value = argv[i + 1];
-    if (value === void 0 || value.startsWith("--")) {
-      throw new Error(`${argv[i]} needs a value.`);
-    }
-    return value;
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--dir") {
-      args.dir = valueAt(i++);
-    } else if (arg === "--locales") {
-      args.localesPath = valueAt(i++);
-    } else if (arg === "--source") {
-      args.sourceLocale = valueAt(i++);
-    } else if (arg === "--branches") {
-      args.branches = valueAt(i++).split(",").map((b) => b.trim()).filter(Boolean);
-    } else if (arg === "--overwrite") {
-      args.overwrite = true;
-    }
-  }
-  return args;
-}
 function toPosix2(p) {
   return p.split(path20.sep).join("/");
 }
@@ -6059,11 +6153,96 @@ function writePlannedFiles(projectDir, files) {
   }
 }
 
-// src/codemod/index.ts
+// src/codemod/command-args.ts
+function commandSpec(command) {
+  const name = command === "build" ? "pack" : command;
+  return name !== void 0 && Object.prototype.hasOwnProperty.call(COMMAND_SPECS, name) ? COMMAND_SPECS[name] : void 0;
+}
 var DEFAULT_STUDIO_PORT = 3010;
 var DEFAULT_APP_ORIGIN = "http://localhost:3000";
-function printHelp() {
-  console.log(`
+var DEFAULT_EXCLUDES = ["node_modules", ".next", "dist", ".git"];
+function parseMigrateArgs(argv) {
+  const parsed = parseCommandArgs(COMMAND_SPECS.migrate, argv);
+  const exclude = parsed.values["--exclude"];
+  return {
+    dir: folderArg(parsed),
+    excludes: exclude === void 0 ? [...DEFAULT_EXCLUDES] : splitList(exclude),
+    dryRun: parsed.flags.has("--dry-run")
+  };
+}
+function parseDoctorArgs(argv) {
+  const parsed = parseCommandArgs(COMMAND_SPECS.doctor, argv);
+  const app = parsed.values["--app"];
+  const args = { dir: folderArg(parsed), share: parsed.flags.has("--share") };
+  if (parsed.values["--locales"] !== void 0) args.localesPath = parsed.values["--locales"];
+  if (parsed.values["--token"] !== void 0) args.token = parsed.values["--token"];
+  if (app !== void 0) {
+    try {
+      args.app = normalizeAppUrl(app);
+    } catch {
+      throw new UsageError(
+        `--app must be an http(s) URL such as http://localhost:3000 or https://user.github.io/repo/ (got "${app}").`
+      );
+    }
+  }
+  return args;
+}
+function parseStudioArgs(argv) {
+  const parsed = parseCommandArgs(COMMAND_SPECS.studio, argv);
+  const port = parsed.values["--port"];
+  const app = parsed.values["--app"];
+  const args = { port: DEFAULT_STUDIO_PORT, appOrigin: DEFAULT_APP_ORIGIN };
+  if (port !== void 0) {
+    const value = Number(port);
+    if (!/^\d+$/.test(port) || value < 1 || value > 65535) {
+      throw new UsageError(`--port must be a port number from 1 to 65535 (got "${port}").`);
+    }
+    args.port = value;
+  }
+  if (app !== void 0) {
+    try {
+      const url = new URL(app);
+      if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("bad protocol");
+      args.appOrigin = url.origin;
+    } catch {
+      throw new UsageError(
+        `--app must be an http(s) origin such as http://localhost:3001 (got "${app}").`
+      );
+    }
+  }
+  return args;
+}
+var SHARE_ONLY = ["--locales", "--source", "--branches"];
+function parseInitArgs(argv) {
+  const parsed = parseCommandArgs(COMMAND_SPECS.init, argv);
+  if (!parsed.flags.has("--share")) {
+    for (const flag of [...SHARE_ONLY, "--overwrite"]) {
+      if (parsed.values[flag] !== void 0 || parsed.flags.has(flag)) {
+        throw new UsageError(`${flag} only works with init --share.`);
+      }
+    }
+    return { share: false, dir: folderArg(parsed) };
+  }
+  const folder = parsed.positionals[0];
+  if (folder !== void 0) {
+    throw new UsageError(
+      `init --share takes the project folder as --dir ${folder}, not as a plain argument.`
+    );
+  }
+  const branches = parsed.values["--branches"];
+  return {
+    share: true,
+    dir: parsed.values["--dir"] ?? ".",
+    localesPath: parsed.values["--locales"],
+    sourceLocale: parsed.values["--source"],
+    branches: branches === void 0 ? void 0 : splitList(branches),
+    overwrite: parsed.flags.has("--overwrite")
+  };
+}
+
+// src/codemod/help.ts
+function helpText() {
+  return `
 LiveLocale (livelocale) CLI
 
 Usage:
@@ -6140,41 +6319,129 @@ Options for apply:
   --source <locale>  Source locale (default: en, else the first locale)
   --force            Apply edits the translator saved with "Save anyway"
   --dry-run          Show what would change without writing files
-  --github-event      Run inside the generated GitHub workflow; reads the link from the event file
-  --branches <a,b>    Branches a link may target (default: the repository's default branch)
+  --github-event     Run inside the generated GitHub workflow; reads the link from the event file
+  --branches <a,b>   Branches a link may target (default: the repository's default branch)
 
 Global Options:
   -h, --help         Show help information
-`);
+  -v, --version      Print the livelocale version
+
+Exit codes:
+  0  Success.
+  1  The command ran and found problems, or could not finish: check found a problem, doctor
+     found a blocking problem, migrate could not convert a file, apply or pack could not finish.
+  2  Usage error: an unknown or missing command, an unknown option, a missing value, an argument
+     the command does not take, or options that do not go together. check also exits 2 when it
+     could not run (missing folder, no locales folder or no locale files in it, unknown --source,
+     TypeScript missing for --hardcoded).
+  build exits with your build command's own code once it has started it.
+`;
 }
-function normalizeOriginArg(value, flag) {
+
+// src/codemod/migrate.ts
+import * as fs14 from "fs";
+import * as path21 from "path";
+var SOURCE_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx"];
+async function loadTransform() {
+  const transform = await Promise.resolve().then(() => (init_transform(), transform_exports));
+  await transform.loadTypeScript();
+  return transform.transformReactI18next;
+}
+async function runMigrate({ dir, excludes, dryRun }, transform) {
+  const absoluteDir = path21.resolve(dir);
+  if (!fs14.existsSync(absoluteDir)) {
+    console.error(`Error: Directory "${dir}" does not exist.`);
+    return 1;
+  }
+  let convert;
   try {
-    const url = new URL(value);
-    if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("bad protocol");
-    return url.origin;
-  } catch {
-    console.error(
-      `Error: ${flag} must be an http(s) origin such as http://localhost:3001 (got "${value}").`
-    );
-    process.exit(1);
+    convert = transform ?? await loadTransform();
+  } catch (err) {
+    console.error(`\u274C ${err.message}`);
+    return 1;
   }
-}
-function normalizeAppArg(value) {
+  console.log(`
+\u{1F680} Starting migration scanner...`);
+  console.log(`\u{1F4C1} Target: ${absoluteDir}`);
+  console.log(`\u{1F6AB} Excluded: ${excludes.join(", ")}`);
+  if (dryRun) {
+    console.log(`\u{1F9EA} Mode: DRY RUN (no files will be modified)`);
+  }
+  console.log("--------------------------------------------------");
+  let scannedCount = 0;
+  let migratedCount = 0;
+  const failed = [];
+  async function walk(currentDir) {
+    const files = fs14.readdirSync(currentDir, { withFileTypes: true });
+    for (const file of files) {
+      const fullPath = path21.join(currentDir, file.name);
+      if (file.isDirectory()) {
+        if (excludes.includes(file.name)) {
+          continue;
+        }
+        await walk(fullPath);
+      } else if (file.isFile() && SOURCE_EXTENSIONS2.includes(path21.extname(file.name))) {
+        scannedCount++;
+        const relativePath = path21.relative(absoluteDir, fullPath);
+        try {
+          const content = fs14.readFileSync(fullPath, "utf8");
+          const result = await convert(content, fullPath);
+          if (result.modified) {
+            if (dryRun) {
+              console.log(`[DRY RUN] Would migrate: ${relativePath}`);
+            } else {
+              fs14.writeFileSync(fullPath, result.code, "utf8");
+              console.log(`\u2705 Migrated: ${relativePath}`);
+            }
+            migratedCount++;
+          }
+        } catch (err) {
+          failed.push(relativePath);
+          console.error(`\u274C Error processing file ${fullPath}:`, err.message);
+        }
+      }
+    }
+  }
+  let walkError;
   try {
-    return normalizeAppUrl(value);
-  } catch {
-    console.error(
-      `Error: --app must be an http(s) URL such as http://localhost:3000 or https://user.github.io/repo/ (got "${value}").`
-    );
-    process.exit(1);
+    await walk(absoluteDir);
+  } catch (err) {
+    walkError = err.message;
+    console.error(`\u274C Walk error:`, err.message);
   }
+  console.log("--------------------------------------------------");
+  console.log(`\u{1F4CA} Summary:`);
+  console.log(`   Scanned:  ${scannedCount} files`);
+  if (dryRun) {
+    console.log(`   Would migrate: ${migratedCount} files`);
+  } else {
+    console.log(`   Migrated: ${migratedCount} files`);
+  }
+  if (failed.length > 0 || walkError !== void 0) {
+    if (failed.length > 0) {
+      console.error(`   Failed:   ${failed.length} file(s)`);
+      for (const file of failed) console.error(`     ${file}`);
+    }
+    if (walkError !== void 0) console.error(`   The scan stopped early: ${walkError}`);
+    console.error(`
+\u274C Not every file was converted. Fix the files above and run migrate again.`);
+    return 1;
+  }
+  console.log(`
+\u{1F389} Done!`);
+  return 0;
+}
+
+// src/codemod/index.ts
+function printHelp() {
+  console.log(helpText());
 }
 function isPortAnswering(port) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const socket = net.connect({ host: "localhost", port });
     const done = (answering) => {
       socket.destroy();
-      resolve18(answering);
+      resolve19(answering);
     };
     socket.setTimeout(1e3, () => done(false));
     socket.once("connect", () => done(true));
@@ -6184,8 +6451,8 @@ function isPortAnswering(port) {
 async function runStudio(port, appOrigin) {
   console.log(`
 \u{1F680} Starting LiveLocale Studio...`);
-  const studioDir = path21.resolve(moduleDir(), "../studio");
-  if (!fs14.existsSync(path21.join(studioDir, "index.html"))) {
+  const studioDir = path22.resolve(moduleDir(), "../studio");
+  if (!fs15.existsSync(path22.join(studioDir, "index.html"))) {
     console.error(`Error: Studio assets not found at "${studioDir}".`);
     console.error(`Did you build the project? Run "npm run build" first.`);
     process.exit(1);
@@ -6217,48 +6484,48 @@ async function runStudio(port, appOrigin) {
 function runInit(projectDir) {
   console.log(`
 \u{1F680} Initializing LiveLocale API handler...`);
-  const absoluteDir = path21.resolve(projectDir);
-  if (!fs14.existsSync(absoluteDir)) {
+  const absoluteDir = path22.resolve(projectDir);
+  if (!fs15.existsSync(absoluteDir)) {
     console.error(`Error: Directory "${projectDir}" does not exist.`);
     process.exit(1);
   }
-  const isTypeScript = fs14.existsSync(path21.join(absoluteDir, "tsconfig.json"));
+  const isTypeScript = fs15.existsSync(path22.join(absoluteDir, "tsconfig.json"));
   const fileExt = isTypeScript ? "ts" : "js";
   console.log(`\u{1F4C1} Target: ${absoluteDir}`);
   console.log(`\u{1F527} Language detected: ${isTypeScript ? "TypeScript" : "JavaScript"}`);
   let hasNextIntl = false;
   let hasReactI18next = false;
-  const targetPkgPath = path21.join(absoluteDir, "package.json");
-  if (fs14.existsSync(targetPkgPath)) {
+  const targetPkgPath = path22.join(absoluteDir, "package.json");
+  if (fs15.existsSync(targetPkgPath)) {
     try {
-      const pkg = JSON.parse(fs14.readFileSync(targetPkgPath, "utf8"));
+      const pkg = JSON.parse(fs15.readFileSync(targetPkgPath, "utf8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       hasNextIntl = Boolean(allDeps["next-intl"]);
       hasReactI18next = Boolean(allDeps["react-i18next"]);
     } catch {
     }
   }
-  const appDirPath = path21.join(absoluteDir, "app");
-  const pagesDirPath = path21.join(absoluteDir, "pages");
-  const srcAppDirPath = path21.join(absoluteDir, "src", "app");
-  const srcPagesDirPath = path21.join(absoluteDir, "src", "pages");
+  const appDirPath = path22.join(absoluteDir, "app");
+  const pagesDirPath = path22.join(absoluteDir, "pages");
+  const srcAppDirPath = path22.join(absoluteDir, "src", "app");
+  const srcPagesDirPath = path22.join(absoluteDir, "src", "pages");
   let targetPath = "";
   let routerType = "";
   let content = "";
-  if (fs14.existsSync(appDirPath)) {
-    targetPath = path21.join(appDirPath, "api", "livelocale", `route.${fileExt}`);
+  if (fs15.existsSync(appDirPath)) {
+    targetPath = path22.join(appDirPath, "api", "livelocale", `route.${fileExt}`);
     routerType = "Next.js App Router (root)";
-  } else if (fs14.existsSync(srcAppDirPath)) {
-    targetPath = path21.join(srcAppDirPath, "api", "livelocale", `route.${fileExt}`);
+  } else if (fs15.existsSync(srcAppDirPath)) {
+    targetPath = path22.join(srcAppDirPath, "api", "livelocale", `route.${fileExt}`);
     routerType = "Next.js App Router (src/)";
-  } else if (fs14.existsSync(pagesDirPath)) {
-    targetPath = path21.join(pagesDirPath, "api", `livelocale.${fileExt}`);
+  } else if (fs15.existsSync(pagesDirPath)) {
+    targetPath = path22.join(pagesDirPath, "api", `livelocale.${fileExt}`);
     routerType = "Next.js Pages Router (root)";
-  } else if (fs14.existsSync(srcPagesDirPath)) {
-    targetPath = path21.join(srcPagesDirPath, "api", `livelocale.${fileExt}`);
+  } else if (fs15.existsSync(srcPagesDirPath)) {
+    targetPath = path22.join(srcPagesDirPath, "api", `livelocale.${fileExt}`);
     routerType = "Next.js Pages Router (src/)";
   } else {
-    targetPath = path21.join(absoluteDir, "app", "api", "livelocale", `route.${fileExt}`);
+    targetPath = path22.join(absoluteDir, "app", "api", "livelocale", `route.${fileExt}`);
     routerType = "Default App Router (app/ not found)";
   }
   console.log(`\u{1F4CD} Project structure: ${routerType}`);
@@ -6286,14 +6553,14 @@ const handler = createLiveLocaleHandler({
 export default handler;
 `;
   }
-  const targetDir = path21.dirname(targetPath);
-  if (!fs14.existsSync(targetDir)) {
-    fs14.mkdirSync(targetDir, { recursive: true });
+  const targetDir = path22.dirname(targetPath);
+  if (!fs15.existsSync(targetDir)) {
+    fs15.mkdirSync(targetDir, { recursive: true });
   }
   try {
-    fs14.writeFileSync(targetPath, content, "utf8");
+    fs15.writeFileSync(targetPath, content, "utf8");
     console.log(`\u2705 Created API Route Handler successfully at:`);
-    console.log(`   ${path21.relative(absoluteDir, targetPath)}`);
+    console.log(`   ${path22.relative(absoluteDir, targetPath)}`);
     if (hasNextIntl) {
       console.log(`
 \u{1F4A1} Detected 'next-intl' in your project!`);
@@ -6314,124 +6581,9 @@ export default handler;
     process.exit(1);
   }
 }
-async function runMigrate(args) {
-  let dir = ".";
-  let excludes = ["node_modules", ".next", "dist", ".git"];
-  let dryRun = false;
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--dir") {
-      dir = args[++i] || ".";
-    } else if (arg === "--exclude") {
-      const val = args[++i];
-      if (val) {
-        excludes = val.split(",").map((s) => s.trim());
-      }
-    } else if (arg === "--dry-run") {
-      dryRun = true;
-    } else {
-      if (arg && !arg.startsWith("--")) {
-        dir = arg;
-      }
-    }
-  }
-  const absoluteDir = path21.resolve(dir);
-  if (!fs14.existsSync(absoluteDir)) {
-    console.error(`Error: Directory "${dir}" does not exist.`);
-    process.exit(1);
-  }
-  let transformReactI18next2;
-  try {
-    const transform = await Promise.resolve().then(() => (init_transform(), transform_exports));
-    await transform.loadTypeScript();
-    transformReactI18next2 = transform.transformReactI18next;
-  } catch (err) {
-    console.error(`\u274C ${err.message}`);
-    process.exit(1);
-  }
-  console.log(`
-\u{1F680} Starting migration scanner...`);
-  console.log(`\u{1F4C1} Target: ${absoluteDir}`);
-  console.log(`\u{1F6AB} Excluded: ${excludes.join(", ")}`);
-  if (dryRun) {
-    console.log(`\u{1F9EA} Mode: DRY RUN (no files will be modified)`);
-  }
-  console.log("--------------------------------------------------");
-  let scannedCount = 0;
-  let migratedCount = 0;
-  async function walk(currentDir) {
-    const files = fs14.readdirSync(currentDir, { withFileTypes: true });
-    for (const file of files) {
-      const fullPath = path21.join(currentDir, file.name);
-      if (file.isDirectory()) {
-        if (excludes.includes(file.name)) {
-          continue;
-        }
-        await walk(fullPath);
-      } else if (file.isFile()) {
-        const ext = path21.extname(file.name);
-        if ([".js", ".jsx", ".ts", ".tsx"].includes(ext)) {
-          scannedCount++;
-          try {
-            const content = fs14.readFileSync(fullPath, "utf8");
-            const result = await transformReactI18next2(content, fullPath);
-            if (result.modified) {
-              migratedCount++;
-              const relativePath = path21.relative(absoluteDir, fullPath);
-              if (dryRun) {
-                console.log(`[DRY RUN] Would migrate: ${relativePath}`);
-              } else {
-                fs14.writeFileSync(fullPath, result.code, "utf8");
-                console.log(`\u2705 Migrated: ${relativePath}`);
-              }
-            }
-          } catch (err) {
-            console.error(`\u274C Error processing file ${fullPath}:`, err.message);
-          }
-        }
-      }
-    }
-  }
-  try {
-    await walk(absoluteDir);
-  } catch (err) {
-    console.error(`\u274C Walk error:`, err.message);
-  }
-  console.log("--------------------------------------------------");
-  console.log(`\u{1F4CA} Summary:`);
-  console.log(`   Scanned:  ${scannedCount} files`);
-  if (dryRun) {
-    console.log(`   Would migrate: ${migratedCount} files`);
-  } else {
-    console.log(`   Migrated: ${migratedCount} files`);
-  }
-  console.log(`
-\u{1F389} Done!`);
-}
-async function runDoctorCommand(args) {
-  let dir = ".";
-  let localesPath;
-  let app;
-  let share = false;
-  let token;
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--dir") {
-      dir = args[++i] || ".";
-    } else if (arg === "--locales") {
-      localesPath = args[++i];
-    } else if (arg === "--app") {
-      app = normalizeAppArg(args[++i] || "");
-    } else if (arg === "--share") {
-      share = true;
-    } else if (arg === "--token") {
-      token = args[++i];
-    } else if (arg && !arg.startsWith("--")) {
-      dir = arg;
-    }
-  }
-  const projectDir = path21.resolve(dir);
-  if (!fs14.existsSync(projectDir)) {
+async function runDoctorCommand({ dir, localesPath, app, share, token }) {
+  const projectDir = path22.resolve(dir);
+  if (!fs15.existsSync(projectDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -6467,19 +6619,25 @@ async function runDoctorCommand(args) {
     );
   }
 }
-async function runCheckCommand(args) {
+async function runCheckCommand(argv) {
+  const json = argv.includes("--json");
+  const couldNotRun = (message, localesDir = null) => {
+    if (json) console.log(JSON.stringify(checkErrorReport(message, localesDir), null, 2));
+    else console.error(`\u274C ${message}`);
+    process.exitCode = CHECK_COULD_NOT_RUN;
+  };
   let parsed;
   try {
-    parsed = parseCheckArgs(args.slice(1));
+    parsed = parseCheckArgs(argv);
   } catch (err) {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
+    couldNotRun(err.message);
+    return;
   }
-  const { dir, localesPath, sourceLocale, unused, strict, json, hardcoded, allow } = parsed;
-  const projectDir = path21.resolve(dir);
-  if (!fs14.existsSync(projectDir)) {
-    console.error(`Error: Directory "${dir}" does not exist.`);
-    process.exit(1);
+  const { dir, localesPath, sourceLocale, unused, strict, hardcoded, allow } = parsed;
+  const projectDir = path22.resolve(dir);
+  if (!fs15.existsSync(projectDir)) {
+    couldNotRun(`Directory "${dir}" does not exist.`);
+    return;
   }
   let report;
   try {
@@ -6493,12 +6651,12 @@ async function runCheckCommand(args) {
       allow
     });
   } catch (err) {
-    console.error(`\u274C ${err.message}`);
-    process.exit(1);
+    couldNotRun(err?.message ?? String(err), path22.resolve(projectDir, localesPath ?? "locales"));
+    return;
   }
   process.exitCode = checkExitCode(report);
   if (json) {
-    console.log(JSON.stringify(report, null, 2));
+    console.log(JSON.stringify(withCheckError(report), null, 2));
     return;
   }
   console.log(`
@@ -6515,7 +6673,7 @@ async function runCheckCommand(args) {
 }
 function printPackSummary(result, projectDir, warnings) {
   for (const warning of warnings) console.log(`\u26A0\uFE0F  ${warning}`);
-  const outRel = path21.relative(projectDir, path21.dirname(result.shareDir)).split(path21.sep).join("/") || ".";
+  const outRel = path22.relative(projectDir, path22.dirname(result.shareDir)).split(path22.sep).join("/") || ".";
   console.log(
     `\u2705 LiveLocale share folder written to ${outRel}/livelocale/ (${result.manifest.locales.length} locales, ${result.manifest.codeKeys.length} code keys, ${result.htmlInjected.length} HTML files linked).`
   );
@@ -6523,9 +6681,9 @@ function printPackSummary(result, projectDir, warnings) {
 }
 async function runPackCommand(args) {
   try {
-    const options = parseShareArgs(args.slice(1));
+    const options = parseShareArgs(args.slice(1), "pack");
     checkPackArgs(options);
-    const projectDir = path21.resolve(options.dir);
+    const projectDir = path22.resolve(options.dir);
     const result = await packOutput({
       projectDir,
       outDir: options.positional[0],
@@ -6539,14 +6697,14 @@ async function runPackCommand(args) {
   } catch (err) {
     if (!(err instanceof PackError)) throw err;
     console.error(`\u274C ${err.message}`);
-    process.exitCode = 1;
+    process.exitCode = err.code === "USAGE" ? USAGE_EXIT_CODE : 1;
   }
 }
 async function runBuildCli(args) {
   try {
-    const options = parseShareArgs(args.slice(1));
+    const options = parseShareArgs(args.slice(1), "build");
     checkBuildArgs(options);
-    const projectDir = path21.resolve(options.dir);
+    const projectDir = path22.resolve(options.dir);
     const result = await runBuildCommand({
       projectDir,
       command: options.command,
@@ -6566,21 +6724,13 @@ async function runBuildCli(args) {
   } catch (err) {
     if (!(err instanceof PackError)) throw err;
     console.error(`\u274C ${err.message}`);
-    process.exitCode = 1;
+    process.exitCode = err.code === "USAGE" ? USAGE_EXIT_CODE : 1;
   }
 }
 async function runInitShareCommand(args) {
-  let parsed;
-  try {
-    parsed = parseInitShareArgs(args.slice(1));
-  } catch (err) {
-    console.error(`\u274C ${err.message}`);
-    process.exitCode = 1;
-    return;
-  }
-  const { dir, localesPath, sourceLocale, branches, overwrite } = parsed;
-  const projectDir = path21.resolve(dir);
-  if (!fs14.existsSync(projectDir)) {
+  const { dir, localesPath, sourceLocale, branches, overwrite } = args;
+  const projectDir = path22.resolve(dir);
+  if (!fs15.existsSync(projectDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -6608,73 +6758,60 @@ async function runInitShareCommand(args) {
     process.exitCode = 1;
   }
 }
+var COMMANDS = ["migrate", "init", "studio", "doctor", "check", "pack", "build", "apply"];
 async function run2() {
   const args = process.argv.slice(2);
-  if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
-    printHelp();
-    process.exit(0);
-  }
-  const COMMANDS = ["migrate", "init", "studio", "doctor", "check", "pack", "build", "apply"];
-  if (!args[0] || !COMMANDS.includes(args[0])) {
-    console.error(`Unknown command: "${args[0]}". Expected one of: ${COMMANDS.join(", ")}.`);
+  const global = args[0] === "help" ? "help" : findGlobalOption(args, commandSpec(args[0]));
+  if (global === "help") {
     printHelp();
-    process.exit(1);
-  }
-  if (args[0] === "doctor") {
-    await runDoctorCommand(args);
-    return;
-  }
-  if (args[0] === "check") {
-    await runCheckCommand(args);
-    return;
-  }
-  if (args[0] === "pack") {
-    await runPackCommand(args);
     return;
   }
-  if (args[0] === "build") {
-    await runBuildCli(args);
+  if (global === "version") {
+    console.log(readOwnVersion());
     return;
   }
-  if (args[0] === "apply") {
-    await runApplyCommand(args.slice(1));
-    return;
-  }
-  if (args[0] === "init" && args.includes("--share")) {
-    await runInitShareCommand(args);
-    return;
+  const [command, ...rest] = args;
+  if (command === void 0) {
+    printHelp();
+    throw new UsageError(
+      "Missing command. Run livelocale <command>, for example livelocale check."
+    );
   }
-  if (args[0] === "init") {
-    let dir = ".";
-    for (let i = 1; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--dir") {
-        dir = args[++i] || ".";
-      } else if (arg && !arg.startsWith("--")) {
-        dir = arg;
-      }
+  if (!COMMANDS.includes(command)) {
+    throw new UsageError(`Unknown command "${command}". Expected one of: ${COMMANDS.join(", ")}.`);
+  }
+  switch (command) {
+    case "doctor":
+      return runDoctorCommand(parseDoctorArgs(rest));
+    case "check":
+      return runCheckCommand(rest);
+    case "pack":
+      return runPackCommand(args);
+    case "build":
+      return runBuildCli(args);
+    case "apply":
+      return runApplyCommand(rest);
+    case "init": {
+      const init = parseInitArgs(rest);
+      if (init.share) return runInitShareCommand(init);
+      runInit(init.dir);
+      return;
     }
-    runInit(dir);
-    process.exit(0);
-  }
-  if (args[0] === "studio") {
-    let port = DEFAULT_STUDIO_PORT;
-    let appOrigin = DEFAULT_APP_ORIGIN;
-    for (let i = 1; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--port") {
-        const val = parseInt(args[++i] || String(DEFAULT_STUDIO_PORT), 10);
-        if (!isNaN(val)) port = val;
-      } else if (arg === "--app") {
-        appOrigin = normalizeOriginArg(args[++i] || "", "--app");
-      }
+    case "studio": {
+      const { port, appOrigin } = parseStudioArgs(rest);
+      return runStudio(port, appOrigin);
     }
-    await runStudio(port, appOrigin);
-    return;
+    default:
+      process.exitCode = await runMigrate(parseMigrateArgs(rest));
+      return;
   }
-  await runMigrate(args);
 }
 run2().catch((err) => {
+  if (err instanceof UsageError) {
+    console.error(`\u274C ${err.message}`);
+    process.exitCode = USAGE_EXIT_CODE;
+    return;
+  }
   console.error(`\u274C ${err?.message || err}`);
   process.exit(1);
 });