glotfile 0.8.8 → 1.0.0

package/dist/server/cli.js

@@ -852,6 +852,153 @@ var init_state = __esm({
   }
 });
 
+// src/server/stats.ts
+function countWords(text) {
+  const t = text.trim();
+  return t === "" ? 0 : t.split(/\s+/).length;
+}
+function namespaceOf(key) {
+  const i = key.indexOf(".");
+  return i === -1 ? "(root)" : key.slice(0, i);
+}
+function pct(n, d) {
+  return d === 0 ? 0 : Math.round(n / d * 1e3) / 10;
+}
+function sourceText(entry, sourceLocale) {
+  const lv = entry.values[sourceLocale];
+  if (!lv) return "";
+  return entry.plural ? lv.forms?.other ?? "" : lv.value ?? "";
+}
+function isPresent(entry, locale) {
+  const lv = entry.values[locale];
+  if (!lv) return false;
+  return entry.plural ? (lv.forms?.other ?? "").trim() !== "" : (lv.value ?? "").trim() !== "";
+}
+function classify(entry, locale) {
+  if (!isPresent(entry, locale)) return "missing";
+  const st = entry.values[locale].state;
+  if (st === "reviewed") return "reviewed";
+  if (st === "needs-review") return "needsReview";
+  return "machine";
+}
+function groupCompletion(state, keys, targets, name) {
+  let translated = 0;
+  let reviewed = 0;
+  for (const k of keys) {
+    const entry = state.keys[k];
+    for (const locale of targets) {
+      const bucket = classify(entry, locale);
+      if (bucket !== "missing") translated++;
+      if (bucket === "reviewed") reviewed++;
+    }
+  }
+  const cells = keys.length * targets.length;
+  return { name, total: keys.length, translatedPct: pct(translated, cells), reviewedPct: pct(reviewed, cells) };
+}
+function worstFirst(a, b) {
+  return a.translatedPct - b.translatedPct || a.name.localeCompare(b.name);
+}
+function computeStats(state) {
+  const { sourceLocale, locales } = state.config;
+  const targets = locales.filter((l) => l !== sourceLocale);
+  const allKeys = Object.keys(state.keys);
+  const expected = allKeys.filter((k) => !state.keys[k].skipTranslate);
+  const locales_ = targets.map((locale) => {
+    const counts = { reviewed: 0, needsReview: 0, machine: 0, missing: 0 };
+    let sourceWords = 0;
+    let missingWords = 0;
+    for (const k of expected) {
+      const entry = state.keys[k];
+      const w = countWords(sourceText(entry, sourceLocale));
+      sourceWords += w;
+      const bucket = classify(entry, locale);
+      counts[bucket]++;
+      if (bucket === "missing") missingWords += w;
+    }
+    const total = expected.length;
+    const translated = counts.reviewed + counts.needsReview + counts.machine;
+    return {
+      locale,
+      total,
+      counts,
+      translated,
+      reviewed: counts.reviewed,
+      translatedPct: pct(translated, total),
+      reviewedPct: pct(counts.reviewed, total),
+      words: { source: sourceWords, missing: missingWords }
+    };
+  });
+  const cells = expected.length * targets.length;
+  let translatedCells = 0;
+  let reviewedCells = 0;
+  for (const ls of locales_) {
+    translatedCells += ls.translated;
+    reviewedCells += ls.reviewed;
+  }
+  const nsMap = /* @__PURE__ */ new Map();
+  for (const k of expected) {
+    const ns = namespaceOf(k);
+    (nsMap.get(ns) ?? nsMap.set(ns, []).get(ns)).push(k);
+  }
+  const byNamespace = [...nsMap.entries()].map(([name, keys]) => groupCompletion(state, keys, targets, name)).sort(worstFirst);
+  const tagMap = /* @__PURE__ */ new Map();
+  for (const k of expected) {
+    for (const tag of state.keys[k].tags ?? []) {
+      (tagMap.get(tag) ?? tagMap.set(tag, []).get(tag)).push(k);
+    }
+  }
+  const byTag = [...tagMap.entries()].map(([name, keys]) => groupCompletion(state, keys, targets, name)).sort(worstFirst);
+  return {
+    totals: {
+      keys: allKeys.length,
+      locales: targets.length,
+      translatedPct: pct(translatedCells, cells),
+      reviewedPct: pct(reviewedCells, cells),
+      sourceWords: expected.reduce((sum, k) => sum + countWords(sourceText(state.keys[k], sourceLocale)), 0)
+    },
+    locales: locales_,
+    byNamespace,
+    byTag
+  };
+}
+var init_stats = __esm({
+  "src/server/stats.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/cell-state.ts
+function cellState(entry, locale, sourceLocale) {
+  const lv = entry.values[locale];
+  if (locale === sourceLocale) {
+    const has = entry.plural ? !!lv?.forms?.other?.trim() : !!lv?.value?.trim();
+    return has ? "source" : "missing";
+  }
+  const present = entry.plural ? categoriesFor(locale).every((c) => (lv?.forms?.[c] ?? "") !== "") : !!lv?.value;
+  if (!present) return "missing";
+  const st = lv.state;
+  return st === "reviewed" ? "reviewed" : st === "needs-review" ? "needs-review" : "machine";
+}
+var EFFECTIVE_STATES;
+var init_cell_state = __esm({
+  "src/server/cell-state.ts"() {
+    "use strict";
+    init_plurals();
+    EFFECTIVE_STATES = ["source", "missing", "machine", "needs-review", "reviewed"];
+  }
+});
+
+// src/server/glob.ts
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+var init_glob = __esm({
+  "src/server/glob.ts"() {
+    "use strict";
+  }
+});
+
 // src/server/adapters/options.ts
 function applyCase(canonical, style) {
   const sep4 = style === "lower-underscore" || style === "bcp47-underscore" ? "_" : "-";
@@ -3132,17 +3279,6 @@ var init_glossary = __esm({
   }
 });
 
-// src/server/glob.ts
-function globToRegExp(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-var init_glob = __esm({
-  "src/server/glob.ts"() {
-    "use strict";
-  }
-});
-
 // src/server/ai/run.ts
 import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
 import { resolve as resolve4, extname } from "path";
@@ -3150,6 +3286,8 @@ function selectRequests(state, opts) {
   const targets = (opts.locales ?? state.config.locales).filter((l) => l !== state.config.sourceLocale);
   const keyRe = opts.keyGlob ? globToRegExp(opts.keyGlob) : null;
   const keySet = opts.keys ? new Set(opts.keys) : null;
+  const stateSet = opts.states ? new Set(opts.states) : null;
+  const skip = (st) => stateSet ? !stateSet.has(st) : !!opts.onlyMissing && st !== "missing";
   const reqs = [];
   let id = 0;
   for (const key of Object.keys(state.keys).sort()) {
@@ -3163,9 +3301,7 @@ function selectRequests(state, opts) {
       const other = sourceForms?.other;
       if (!sourceForms || !other) continue;
       for (const locale of targets) {
-        const have = entry.values[locale]?.forms ?? {};
-        const complete = categoriesFor(locale).every((c) => (have[c] ?? "") !== "");
-        if (opts.onlyMissing && complete) continue;
+        if (skip(cellState(entry, locale, state.config.sourceLocale))) continue;
         const glossary = relevantGlossary(other, locale, state.glossary);
         const literals = quotedLiterals(other);
         reqs.push({
@@ -3187,8 +3323,7 @@ function selectRequests(state, opts) {
     const source = sourceLv?.value;
     if (!source) continue;
     for (const locale of targets) {
-      const existing = entry.values[locale]?.value;
-      if (opts.onlyMissing && existing) continue;
+      if (skip(cellState(entry, locale, state.config.sourceLocale))) continue;
       const glossary = relevantGlossary(source, locale, state.glossary);
       const literals = quotedLiterals(source);
       reqs.push({
@@ -3349,6 +3484,7 @@ var init_run = __esm({
     init_placeholders();
     init_plurals();
     init_state();
+    init_cell_state();
     init_glob();
     init_batch();
     MEDIA_TYPES = {
@@ -6601,121 +6737,6 @@ var init_run3 = __esm({
   }
 });
 
-// src/server/stats.ts
-function countWords(text) {
-  const t = text.trim();
-  return t === "" ? 0 : t.split(/\s+/).length;
-}
-function namespaceOf(key) {
-  const i = key.indexOf(".");
-  return i === -1 ? "(root)" : key.slice(0, i);
-}
-function pct(n, d) {
-  return d === 0 ? 0 : Math.round(n / d * 1e3) / 10;
-}
-function sourceText(entry, sourceLocale) {
-  const lv = entry.values[sourceLocale];
-  if (!lv) return "";
-  return entry.plural ? lv.forms?.other ?? "" : lv.value ?? "";
-}
-function isPresent(entry, locale) {
-  const lv = entry.values[locale];
-  if (!lv) return false;
-  return entry.plural ? (lv.forms?.other ?? "").trim() !== "" : (lv.value ?? "").trim() !== "";
-}
-function classify(entry, locale) {
-  if (!isPresent(entry, locale)) return "missing";
-  const st = entry.values[locale].state;
-  if (st === "reviewed") return "reviewed";
-  if (st === "needs-review") return "needsReview";
-  return "machine";
-}
-function groupCompletion(state, keys, targets, name) {
-  let translated = 0;
-  let reviewed = 0;
-  for (const k of keys) {
-    const entry = state.keys[k];
-    for (const locale of targets) {
-      const bucket = classify(entry, locale);
-      if (bucket !== "missing") translated++;
-      if (bucket === "reviewed") reviewed++;
-    }
-  }
-  const cells = keys.length * targets.length;
-  return { name, total: keys.length, translatedPct: pct(translated, cells), reviewedPct: pct(reviewed, cells) };
-}
-function worstFirst(a, b) {
-  return a.translatedPct - b.translatedPct || a.name.localeCompare(b.name);
-}
-function computeStats(state) {
-  const { sourceLocale, locales } = state.config;
-  const targets = locales.filter((l) => l !== sourceLocale);
-  const allKeys = Object.keys(state.keys);
-  const expected = allKeys.filter((k) => !state.keys[k].skipTranslate);
-  const locales_ = targets.map((locale) => {
-    const counts = { reviewed: 0, needsReview: 0, machine: 0, missing: 0 };
-    let sourceWords = 0;
-    let missingWords = 0;
-    for (const k of expected) {
-      const entry = state.keys[k];
-      const w = countWords(sourceText(entry, sourceLocale));
-      sourceWords += w;
-      const bucket = classify(entry, locale);
-      counts[bucket]++;
-      if (bucket === "missing") missingWords += w;
-    }
-    const total = expected.length;
-    const translated = counts.reviewed + counts.needsReview + counts.machine;
-    return {
-      locale,
-      total,
-      counts,
-      translated,
-      reviewed: counts.reviewed,
-      translatedPct: pct(translated, total),
-      reviewedPct: pct(counts.reviewed, total),
-      words: { source: sourceWords, missing: missingWords }
-    };
-  });
-  const cells = expected.length * targets.length;
-  let translatedCells = 0;
-  let reviewedCells = 0;
-  for (const ls of locales_) {
-    translatedCells += ls.translated;
-    reviewedCells += ls.reviewed;
-  }
-  const nsMap = /* @__PURE__ */ new Map();
-  for (const k of expected) {
-    const ns = namespaceOf(k);
-    (nsMap.get(ns) ?? nsMap.set(ns, []).get(ns)).push(k);
-  }
-  const byNamespace = [...nsMap.entries()].map(([name, keys]) => groupCompletion(state, keys, targets, name)).sort(worstFirst);
-  const tagMap = /* @__PURE__ */ new Map();
-  for (const k of expected) {
-    for (const tag of state.keys[k].tags ?? []) {
-      (tagMap.get(tag) ?? tagMap.set(tag, []).get(tag)).push(k);
-    }
-  }
-  const byTag = [...tagMap.entries()].map(([name, keys]) => groupCompletion(state, keys, targets, name)).sort(worstFirst);
-  return {
-    totals: {
-      keys: allKeys.length,
-      locales: targets.length,
-      translatedPct: pct(translatedCells, cells),
-      reviewedPct: pct(reviewedCells, cells),
-      sourceWords: expected.reduce((sum, k) => sum + countWords(sourceText(state.keys[k], sourceLocale)), 0)
-    },
-    locales: locales_,
-    byNamespace,
-    byTag
-  };
-}
-var init_stats = __esm({
-  "src/server/stats.ts"() {
-    "use strict";
-  }
-});
-
 // src/server/checks.ts
 function runChecks(state, opts = {}) {
   const ruleOff = (id) => state.config.lint?.rules?.[CHECK_RULE[id]] === "off";
@@ -8406,6 +8427,129 @@ var init_server = __esm({
 
 // src/server/cli.ts
 init_state();
+init_stats();
+import { resolve as resolve11, dirname as dirname5, join as join19, basename as basename2 } from "path";
+import { readFileSync as readFileSync24, existsSync as existsSync14, mkdirSync as mkdirSync6, cpSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/server/agent-cli.ts
+init_state();
+init_cell_state();
+init_glob();
+function projectCell(cell, fields) {
+  const out = {};
+  for (const f of fields) {
+    if (f === "value" && cell.value !== void 0) out.value = cell.value;
+    else if (f === "value" && cell.forms !== void 0) out.forms = cell.forms;
+    else if (f === "state") out.state = cell.state;
+    else if (f === "updatedAt" && cell.updatedAt !== void 0) out.updatedAt = cell.updatedAt;
+  }
+  return out;
+}
+function runGet(state, opts) {
+  const { sourceLocale } = state.config;
+  const shown = (opts.locales?.length ? opts.locales : state.config.locales).map(canonLocale);
+  const targetsShown = shown.filter((l) => l !== sourceLocale);
+  const res = opts.keyGlobs?.length ? opts.keyGlobs.map(globToRegExp) : null;
+  const stateSet = opts.states?.length ? new Set(opts.states) : null;
+  const fields = opts.fields?.length ? opts.fields : ["value", "state"];
+  const fullEntry = fields.includes("all");
+  const keys = [];
+  const json = {};
+  const ndjson = [];
+  for (const key of Object.keys(state.keys).sort()) {
+    if (res && !res.some((re) => re.test(key))) continue;
+    const entry = state.keys[key];
+    if (stateSet && !targetsShown.some((l) => stateSet.has(cellState(entry, l, sourceLocale)))) continue;
+    keys.push(key);
+    if (fullEntry) {
+      const values = {};
+      for (const l of shown) if (entry.values[l]) values[l] = entry.values[l];
+      json[key] = { ...entry, values };
+      ndjson.push({ key, ...entry, values });
+      continue;
+    }
+    const cells = {};
+    for (const locale of shown) {
+      const st = cellState(entry, locale, sourceLocale);
+      if (stateSet && locale !== sourceLocale && !stateSet.has(st)) continue;
+      const lv = entry.values[locale];
+      const cell = entry.plural ? { forms: lv?.forms ?? {}, state: st, updatedAt: lv?.updatedAt } : { value: lv?.value ?? "", state: st, updatedAt: lv?.updatedAt };
+      const projected = projectCell(cell, fields);
+      cells[locale] = projected;
+      ndjson.push({ key, locale, ...projected });
+    }
+    json[key] = cells;
+  }
+  return { keys, json, ndjson };
+}
+function applyOne(state, op, clock) {
+  switch (op.op) {
+    case "create":
+      createKey(state, op.key, op.value, clock);
+      return;
+    case "set-source":
+      setSourceValue(state, op.key, op.value);
+      return;
+    case "set-target":
+      setTargetValue(state, op.key, op.locale, op.value, clock);
+      if (op.state && op.state !== "reviewed") setKeyState(state, op.key, op.locale, op.state);
+      return;
+    case "set-source-forms":
+      setSourcePluralForms(state, op.key, op.forms);
+      return;
+    case "set-forms":
+      setPluralForms(state, op.key, op.locale, op.forms, clock);
+      if (op.state && op.state !== "reviewed") setKeyState(state, op.key, op.locale, op.state);
+      return;
+    case "set-state":
+      setKeyState(state, op.key, op.locale, op.state);
+      return;
+    case "clear":
+      clearValue(state, op.key, op.locale);
+      return;
+    default:
+      throw new Error(`Unknown op: ${op.op ?? "(missing)"}`);
+  }
+}
+function parseOps(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`apply expects a JSON array of operations on stdin: ${e.message}`);
+  }
+  if (!Array.isArray(data)) throw new Error("apply expects a JSON array of operations on stdin");
+  return data.map((o, i) => {
+    if (!o || typeof o !== "object" || typeof o.op !== "string") {
+      throw new Error(`operation ${i} is not an { "op": ... } object`);
+    }
+    return o;
+  });
+}
+function applyOps(state, ops, opts = {}) {
+  const clock = opts.clock ?? systemClock;
+  const touched = /* @__PURE__ */ new Set();
+  const errors = [];
+  let applied = 0;
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    try {
+      applyOne(state, op, clock);
+      applied++;
+      if (op.key) touched.add(op.key);
+    } catch (e) {
+      errors.push({ index: i, op: op.op, key: op.key, error: e instanceof Error ? e.message : String(e) });
+      if (!opts.continueOnError) break;
+    }
+  }
+  return { applied, keysTouched: [...touched].sort(), errors };
+}
+
+// src/server/cli.ts
+init_cell_state();
+init_glob();
+init_schema();
 init_export_run();
 init_storage();
 init_ai();
@@ -8425,9 +8569,6 @@ init_usage();
 init_context();
 init_run2();
 init_outputs();
-import { resolve as resolve11, dirname as dirname5, join as join19, basename as basename2 } from "path";
-import { readFileSync as readFileSync24, existsSync as existsSync14, mkdirSync as mkdirSync6, cpSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/lint/locate.ts
 function locate(rawText, key) {
@@ -8503,7 +8644,7 @@ function formatSarif(report, ctx) {
 }
 
 // src/server/cli.ts
-var COMMANDS = ["serve", "export", "translate", "lint", "check", "import", "sync", "build-context", "scan", "prune", "split", "skill", "batch"];
+var COMMANDS = ["serve", "export", "translate", "lint", "check", "import", "sync", "build-context", "scan", "prune", "split", "skill", "batch", "get", "stats", "set", "set-state", "clear", "apply"];
 var isCommand = (s) => s != null && COMMANDS.includes(s);
 function parseArgs(argv) {
   const statePath = resolve11(process.cwd(), "glotfile.json");
@@ -8579,9 +8720,21 @@ function parseArgs(argv) {
     else if (flag === "--batch") args.batch = true;
     else if (flag === "--wait") args.wait = true;
     else if (flag === "--print") args.print = true;
+    else if (flag === "--state" && next) {
+      args.states = next.split(",");
+      i++;
+    } else if (flag === "--fields" && next) {
+      args.fields = next.split(",");
+      i++;
+    } else if (flag === "--keys-only") args.keysOnly = true;
+    else if (flag === "--value" && next) {
+      args.value = next;
+      i++;
+    } else if (flag === "--create") args.create = true;
+    else if (flag === "--continue-on-error") args.continueOnError = true;
     else if (args.command === "batch" && (flag === "status" || flag === "apply" || flag === "cancel")) {
       args.batchAction = flag;
-    }
+    } else if (!flag.startsWith("-")) (args.positionals ??= []).push(flag);
   }
   return args;
 }
@@ -8641,16 +8794,42 @@ function makeProviderOrExit(ai) {
     return null;
   }
 }
+function parseStates(args, allowSource) {
+  if (!args.states?.length) return void 0;
+  const allowed = allowSource ? EFFECTIVE_STATES : EFFECTIVE_STATES.filter((s) => s !== "source");
+  for (const s of args.states) {
+    if (!allowed.includes(s)) {
+      console.error(`Unknown --state '${s}'. Expected one of: ${allowed.join(", ")}.`);
+      process.exit(1);
+    }
+  }
+  return args.states;
+}
+function translateSelection(args) {
+  const states = parseStates(args, false);
+  return {
+    locales: args.locales,
+    keyGlob: args.keyGlob,
+    ...states ? { states } : { onlyMissing: args.all ? false : args.onlyMissing ?? true }
+  };
+}
+function readStdin() {
+  try {
+    return readFileSync24(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function matchKeys(state, glob) {
+  const re = globToRegExp(glob);
+  return Object.keys(state.keys).filter((k) => re.test(k)).sort();
+}
 async function runTranslate(args) {
   const state = loadState(args.statePath);
   const projectRoot = dirname5(resolve11(args.statePath));
   if (args.estimate) {
     const ai = loadLocalSettings(projectRoot).ai;
-    const est = estimateTranslation(state, ai, {
-      onlyMissing: args.all ? false : args.onlyMissing ?? true,
-      locales: args.locales,
-      keyGlob: args.keyGlob
-    });
+    const est = estimateTranslation(state, ai, translateSelection(args));
     if (!est.requests) {
       console.log("Nothing to translate.");
       return;
@@ -8669,13 +8848,7 @@ async function runTranslate(args) {
     }
     return;
   }
-  const reqs = selectRequests(state, {
-    // Default to translating only empty values; --all forces a full re-translate
-    // (overwriting existing translations). --only missing stays as a no-op alias.
-    onlyMissing: args.all ? false : args.onlyMissing ?? true,
-    locales: args.locales,
-    keyGlob: args.keyGlob
-  });
+  const reqs = selectRequests(state, translateSelection(args));
   const toTranslate = [...reqs];
   if (args.batch) {
     if (!toTranslate.length) {
@@ -9235,6 +9408,172 @@ function runSkill(args) {
   cpSync(SKILL_SRC, dest, { recursive: true });
   console.log(`Installed the glotfile skill to ${dest}. Restart Claude Code to pick it up.`);
 }
+function runGetCmd(args) {
+  const state = loadState(args.statePath);
+  const keyGlobs = [...args.positionals ?? [], ...args.keyGlob ? [args.keyGlob] : []];
+  const out = runGet(state, {
+    keyGlobs: keyGlobs.length ? keyGlobs : void 0,
+    locales: args.locales,
+    states: parseStates(args, true),
+    fields: args.fields
+  });
+  if (args.keysOnly) {
+    for (const k of out.keys) console.log(k);
+    return;
+  }
+  if (args.format === "ndjson") {
+    for (const row of out.ndjson) console.log(JSON.stringify(row));
+    return;
+  }
+  console.log(JSON.stringify(out.json, null, 2));
+}
+function runStatsCmd(args) {
+  const state = loadState(args.statePath);
+  const stats = computeStats(state);
+  let locales = stats.locales;
+  if (args.locales?.length) {
+    const want = new Set(args.locales.map(canonLocale));
+    locales = locales.filter((l) => want.has(l.locale));
+  }
+  if (args.format === "text") {
+    console.log(`${stats.totals.keys} key(s) \xB7 ${stats.totals.locales} target locale(s) \xB7 ${stats.totals.translatedPct}% translated, ${stats.totals.reviewedPct}% reviewed`);
+    for (const l of locales) {
+      const c = l.counts;
+      console.log(`  ${l.locale.padEnd(8)} ${String(l.translatedPct).padStart(5)}% translated  (reviewed ${c.reviewed}, machine ${c.machine}, needs-review ${c.needsReview}, missing ${c.missing})`);
+    }
+    return;
+  }
+  console.log(JSON.stringify({ totals: stats.totals, locales }, null, 2));
+}
+function countNeedsReview(state, key) {
+  const entry = state.keys[key];
+  if (!entry) return 0;
+  let n = 0;
+  for (const [loc, lv] of Object.entries(entry.values)) {
+    if (loc !== state.config.sourceLocale && lv.state === "needs-review") n++;
+  }
+  return n;
+}
+function runSet(args) {
+  const pos = args.positionals ?? [];
+  const key = pos[0];
+  if (!key) {
+    console.error("Usage: glotfile set <key> [value] [--locale <code>] [--state <state>] [--create]");
+    process.exitCode = 1;
+    return;
+  }
+  let value = args.value ?? pos[1];
+  if (value === void 0) {
+    const piped = readStdin();
+    value = piped.length ? piped.replace(/\r?\n$/, "") : void 0;
+  }
+  if (value === void 0) {
+    console.error('set requires a value (positional, --value, or piped on stdin). Use --value "" to set an empty value.');
+    process.exitCode = 1;
+    return;
+  }
+  const state = loadState(args.statePath);
+  const sl = state.config.sourceLocale;
+  const locale = args.locales?.[0] ? canonLocale(args.locales[0]) : sl;
+  try {
+    if (locale === sl) {
+      if (args.create && !state.keys[key]) createKey(state, key, value);
+      const before = countNeedsReview(state, key);
+      setSourceValue(state, key, value);
+      saveState(args.statePath, state);
+      const flipped = countNeedsReview(state, key) - before;
+      console.log(`set ${key} (${sl})${flipped > 0 ? ` \u2014 ${flipped} translation(s) now need re-translation (run \`glotfile translate --state needs-review\`)` : ""}`);
+    } else {
+      setTargetValue(state, key, locale, value);
+      const override = args.states?.[0];
+      if (override && override !== "reviewed") setKeyState(state, key, locale, override);
+      saveState(args.statePath, state);
+      console.log(`set ${key} (${locale})`);
+    }
+  } catch (e) {
+    console.error(e.message);
+    process.exitCode = 1;
+  }
+}
+function runSetStateCmd(args) {
+  const pos = args.positionals ?? [];
+  const sel = args.keyGlob ?? pos[0];
+  const stateName = args.keyGlob ? pos[0] : pos[1];
+  if (!sel || !stateName) {
+    console.error("Usage: glotfile set-state <key|glob> <state> [--locale <list>]  (state: machine | needs-review | reviewed)");
+    process.exitCode = 1;
+    return;
+  }
+  if (!STATES.includes(stateName)) {
+    console.error(`Unknown state '${stateName}'. Expected one of: ${STATES.join(", ")}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const state = loadState(args.statePath);
+  const sl = state.config.sourceLocale;
+  const locales = (args.locales?.length ? args.locales : state.config.locales.filter((l) => l !== sl)).map(canonLocale);
+  const keys = matchKeys(state, sel);
+  let n = 0;
+  for (const key of keys) {
+    for (const loc of locales) {
+      if (state.keys[key].values[loc]) {
+        setKeyState(state, key, loc, stateName);
+        n++;
+      }
+    }
+  }
+  saveState(args.statePath, state);
+  console.log(`Set ${n} cell(s) to ${stateName} across ${keys.length} key(s).`);
+}
+function runClearCmd(args) {
+  const sel = args.keyGlob ?? args.positionals?.[0];
+  if (!sel) {
+    console.error("Usage: glotfile clear <key|glob> --locale <list>");
+    process.exitCode = 1;
+    return;
+  }
+  if (!args.locales?.length) {
+    console.error("clear requires --locale <list> (the locale(s) to empty).");
+    process.exitCode = 1;
+    return;
+  }
+  const state = loadState(args.statePath);
+  const sl = state.config.sourceLocale;
+  const locales = args.locales.map(canonLocale);
+  if (locales.includes(sl)) {
+    console.error(`Cannot clear the source locale (${sl}); edit it with \`glotfile set\` instead.`);
+    process.exitCode = 1;
+    return;
+  }
+  const keys = matchKeys(state, sel);
+  let n = 0;
+  for (const key of keys) {
+    for (const loc of locales) {
+      if (state.keys[key].values[loc]) {
+        clearValue(state, key, loc);
+        n++;
+      }
+    }
+  }
+  saveState(args.statePath, state);
+  console.log(`Cleared ${n} value(s) \u2192 untranslated.`);
+}
+function runApply(args) {
+  let ops;
+  try {
+    ops = parseOps(readStdin());
+  } catch (e) {
+    console.error(e.message);
+    process.exitCode = 1;
+    return;
+  }
+  const state = loadState(args.statePath);
+  const r = applyOps(state, ops, { continueOnError: args.continueOnError });
+  const saved = (args.continueOnError || r.errors.length === 0) && !args.dryRun;
+  if (saved) saveState(args.statePath, state);
+  console.log(JSON.stringify({ applied: r.applied, keysTouched: r.keysTouched, saved, dryRun: !!args.dryRun, errors: r.errors }, null, 2));
+  if (r.errors.length) process.exitCode = 1;
+}
 var GLOBAL_OPTS = [
   ["-f, --file <path>", "State file to use (default: ./glotfile.json)"],
   ["-h, --help", "Show this help"]
@@ -9258,9 +9597,10 @@ var COMMAND_HELP = {
   },
   translate: {
     summary: "AI-translate missing strings into your target locales (writes back to the state file).",
-    usage: "glotfile translate [--all] [--estimate] [--locale <list>] [--key <glob>]",
+    usage: "glotfile translate [--all] [--state <list>] [--estimate] [--locale <list>] [--key <glob>]",
     options: [
       ["--all", "Re-translate every string, not just empty values"],
+      ["--state <list>", "Re-translate only targets in these states: missing|machine|needs-review|reviewed (e.g. needs-review = strings a source edit invalidated)"],
       ["--estimate", "Print batches, tokens and estimated cost without translating"],
       ["--locale <list>", "Comma-separated target locales (alias: --locales)"],
       ["--key <glob>", "Only keys matching this glob"],
@@ -9355,6 +9695,64 @@ var COMMAND_HELP = {
       ["apply", "Fetch results and write translations (auto-runs when finished)"],
       ["cancel", "Cancel the pending batch and discard the handle"]
     ]
+  },
+  get: {
+    summary: "Extract values from the catalog (filtered) without loading the whole file. Prints JSON.",
+    usage: "glotfile get [<key-glob>\u2026] [--key <glob>] [--locale <list>] [--state <list>] [--fields <list>] [--keys-only] [--format json|ndjson]",
+    options: [
+      ["<key-glob>\u2026", "Key globs to include (e.g. auth.*); positional, repeatable. Default: all keys"],
+      ["--key <glob>", "Additional key glob (merged with positionals)"],
+      ["--locale <list>", "Locales to show (default: all configured locales, source included)"],
+      ["--state <list>", "Only keys whose shown target locales are in these states: source|missing|machine|needs-review|reviewed"],
+      ["--fields <list>", "Cell fields to project: value,state,updatedAt (default value,state); 'all' = the full key entry"],
+      ["--keys-only", "Print just the matched key names, one per line"],
+      ["--format <fmt>", "json (default, nested) or ndjson (one row per cell)"]
+    ]
+  },
+  stats: {
+    summary: "Per-locale progress counts (translated / reviewed / machine / needs-review / missing).",
+    usage: "glotfile stats [--locale <list>] [--format json|text]",
+    options: [
+      ["--locale <list>", "Restrict to these comma-separated locales"],
+      ["--format <fmt>", "json (default) or text"]
+    ]
+  },
+  set: {
+    summary: "Set one value: the source string (default \u2014 flips downstream translations to needs-review) or a target (--locale).",
+    usage: "glotfile set <key> [value] [--locale <code>] [--state <state>] [--create]",
+    options: [
+      ["<key> [value]", "Key, then the value (or pass --value, or pipe it on stdin)"],
+      ["--locale <code>", "Set this target locale instead of the source"],
+      ["--value <v>", "The value (alternative to the positional / stdin)"],
+      ["--state <state>", "Resulting state for a target write (default reviewed): machine|needs-review|reviewed"],
+      ["--create", "Create the key (scalar) if it does not exist yet"]
+    ]
+  },
+  "set-state": {
+    summary: "Flip the review state of one key \u2014 or many via a glob \u2014 across locales.",
+    usage: "glotfile set-state <key|glob> <state> [--locale <list>]",
+    options: [
+      ["<key|glob> <state>", "Key/glob, then machine | needs-review | reviewed"],
+      ["--key <glob>", "Glob selecting keys (alternative to the positional key)"],
+      ["--locale <list>", "Locales to affect (default: every target locale)"]
+    ]
+  },
+  clear: {
+    summary: "Empty target value(s) so they read as untranslated (and get refilled by a plain translate).",
+    usage: "glotfile clear <key|glob> --locale <list>",
+    options: [
+      ["<key|glob>", "Key or glob to clear"],
+      ["--key <glob>", "Glob selecting keys (alternative to the positional key)"],
+      ["--locale <list>", "Required: the locale(s) to empty (cannot be the source)"]
+    ]
+  },
+  apply: {
+    summary: "Apply a JSON batch of write operations from stdin in one load \u2192 save (atomic by default).",
+    usage: "glotfile apply [--dry-run] [--continue-on-error] < ops.json",
+    options: [
+      ["--dry-run", "Report what would change without writing"],
+      ["--continue-on-error", "Apply the survivors past a failing op instead of stopping (and saving nothing)"]
+    ]
   }
 };
 function formatOpts(opts) {
@@ -9413,6 +9811,12 @@ async function main(argv) {
   if (args.command === "split") return runSplit(args);
   if (args.command === "skill") return runSkill(args);
   if (args.command === "batch") return runBatch(args);
+  if (args.command === "get") return runGetCmd(args);
+  if (args.command === "stats") return runStatsCmd(args);
+  if (args.command === "set") return runSet(args);
+  if (args.command === "set-state") return runSetStateCmd(args);
+  if (args.command === "clear") return runClearCmd(args);
+  if (args.command === "apply") return runApply(args);
   const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const { url } = await startServer2({ statePath: args.statePath, dev: args.dev, open: !args.noOpen });
   if (args.dev) console.log(`Glotfile dev API on ${url} \u2014 open the UI at the Vite "Local:" URL above`);