@inline-i18n-multi/cli 0.7.0 → 0.9.0

package/README.md

@@ -14,12 +14,23 @@ npm install -g @inline-i18n-multi/cli
 
 ## Commands
 
-### Extract Translations
+### Extract Translations (v0.9.0)
 
-Extract all translations from your codebase:
+Extract all inline translations from your codebase into a structured JSON file:
 
 ```bash
 npx inline-i18n extract --output translations.json
+npx inline-i18n extract --src ./src --output i18n/translations.json
+```
+
+The extracted file contains all `it()`, `T`, and key-based translations found in source files, grouped by file path:
+
+```json
+{
+  "src/Header.tsx": [
+    { "key": "greeting", "translations": { "en": "Hello", "ko": "안녕하세요" } }
+  ]
+}
 ```
 
 ### Check Missing Translations
@@ -37,6 +48,26 @@ Check translation consistency across locales:
 ```bash
 npx inline-i18n validate
 npx inline-i18n validate --locales en ko ja
+npx inline-i18n validate --unused
+```
+
+### Detect Unused Keys (v0.8.0)
+
+Find translation keys defined in dictionaries but never referenced in source code:
+
+```bash
+npx inline-i18n validate --unused
+```
+
+Example output:
+
+```
+Found 2 unused translation key(s):
+
+  - old.feature.title
+    defined in src/locales.ts:5
+  - deprecated.banner
+    defined in src/locales.ts:12
 ```
 
 ### Strict Mode (v0.7.0)
@@ -54,14 +85,24 @@ Strict mode detects:
 Example output:
 
 ```
-⚠ ICU type mismatch:
-  en: count → plural
-  ko: count → select
-  Details: Variable "count" has type "plural" in en but "select" in ko
+ICU type mismatch between translations
+  src/Header.tsx:12
+    en: {count, plural, one {# item} other {# items}}
+    ko: {count, select, male {He} female {She}}
 
-✗ 2 issues found
+Found 1 issue(s)
 ```
 
+### Generate Types (v0.8.0)
+
+Generate TypeScript type definitions from your translation keys for type-safe `t()` calls:
+
+```bash
+npx inline-i18n typegen --output src/i18n.d.ts
+```
+
+This scans your dictionaries and produces a `.d.ts` file with autocomplete-ready key types.
+
 ### Generate Report
 
 Generate a translation coverage report:
@@ -70,6 +111,31 @@ Generate a translation coverage report:
 npx inline-i18n report
 ```
 
+### Watch Mode (v0.9.0)
+
+Run `validate` or `typegen` in watch mode to automatically re-run on file changes:
+
+```bash
+npx inline-i18n validate --watch
+npx inline-i18n typegen --output src/i18n.d.ts --watch
+```
+
+Watch mode monitors your source directory for changes and re-executes the command on each save. Useful during development to catch translation issues or regenerate types in real time.
+
+### Context System Support (v0.9.0)
+
+The CLI commands (`extract`, `validate`, `typegen`) recognize contextual translation keys using the `key#context` convention:
+
+```json
+{
+  "greeting": "Hello",
+  "greeting#formal": "Good day",
+  "greeting#casual": "Hey"
+}
+```
+
+Validation checks context variants for completeness across locales. Type generation includes context-aware overloads for `t()`.
+
 ## Options
 
 ```
@@ -77,7 +143,9 @@ npx inline-i18n report
 --output, -o    Output file path
 --locales, -l   Comma-separated list of locales
 --format, -f    Output format: json, csv (default: json)
---strict, -s    Enable strict mode (ICU type consistency check)
+--strict        Enable strict mode (ICU type consistency check)
+--unused        Detect unused translation keys (validate command)
+--watch, -w     Watch mode for validate/typegen (re-run on file changes)
 ```
 
 ## Documentation

package/dist/bin.js

@@ -148,6 +148,125 @@ function parseFile(filePath) {
   });
   return entries;
 }
+function flattenObjectKeys(node, prefix = "") {
+  const keys = [];
+  if (node.type !== "ObjectExpression" || !node.properties) return keys;
+  for (const prop of node.properties) {
+    if (prop.type !== "ObjectProperty") continue;
+    let propName;
+    if (prop.key.type === "Identifier") propName = prop.key.name;
+    else if (prop.key.type === "StringLiteral") propName = prop.key.value;
+    if (!propName) continue;
+    const fullKey = prefix ? `${prefix}.${propName}` : propName;
+    if (prop.value.type === "StringLiteral") {
+      keys.push(fullKey);
+    } else if (prop.value.type === "ObjectExpression") {
+      keys.push(...flattenObjectKeys(prop.value, fullKey));
+    }
+  }
+  return keys;
+}
+function parseDictionaryKeys(filePath) {
+  const entries = [];
+  const code = fs.readFileSync(filePath, "utf-8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"]
+    });
+  } catch {
+    return [];
+  }
+  (0, import_traverse.default)(ast, {
+    CallExpression(nodePath) {
+      const { node } = nodePath;
+      const { callee } = node;
+      if (callee.type !== "Identifier" || callee.name !== "loadDictionaries") return;
+      const args = node.arguments;
+      const loc = node.loc;
+      if (!loc || !args[0] || args[0].type !== "ObjectExpression") return;
+      let namespace = "default";
+      if (args[1]?.type === "StringLiteral") {
+        namespace = args[1].value;
+      }
+      const dictObj = args[0];
+      const allKeys = /* @__PURE__ */ new Set();
+      for (const localeProp of dictObj.properties) {
+        if (localeProp.type !== "ObjectProperty") continue;
+        if (localeProp.value.type !== "ObjectExpression") continue;
+        const localeKeys = flattenObjectKeys(localeProp.value);
+        for (const key of localeKeys) {
+          allKeys.add(key);
+        }
+      }
+      if (allKeys.size > 0) {
+        entries.push({
+          file: filePath,
+          line: loc.start.line,
+          namespace,
+          keys: [...allKeys]
+        });
+      }
+    }
+  });
+  return entries;
+}
+function parseTCalls(filePath) {
+  const entries = [];
+  const code = fs.readFileSync(filePath, "utf-8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"]
+    });
+  } catch {
+    return [];
+  }
+  (0, import_traverse.default)(ast, {
+    CallExpression(nodePath) {
+      const { node } = nodePath;
+      const { callee } = node;
+      if (callee.type !== "Identifier" || callee.name !== "t") return;
+      const args = node.arguments;
+      const loc = node.loc;
+      if (!loc || !args[0] || args[0].type !== "StringLiteral") return;
+      entries.push({
+        file: filePath,
+        line: loc.start.line,
+        key: args[0].value
+      });
+    }
+  });
+  return entries;
+}
+async function extractProjectDictionaryKeys(options = {}) {
+  const {
+    cwd = process.cwd(),
+    include = ["**/*.{ts,tsx,js,jsx}"],
+    exclude = ["**/node_modules/**", "**/dist/**", "**/.next/**"]
+  } = options;
+  const files = await (0, import_fast_glob.default)(include, { cwd, ignore: exclude, absolute: true });
+  const allEntries = [];
+  for (const file of files) {
+    allEntries.push(...parseDictionaryKeys(file));
+  }
+  return allEntries;
+}
+async function extractProjectTCalls(options = {}) {
+  const {
+    cwd = process.cwd(),
+    include = ["**/*.{ts,tsx,js,jsx}"],
+    exclude = ["**/node_modules/**", "**/dist/**", "**/.next/**"]
+  } = options;
+  const files = await (0, import_fast_glob.default)(include, { cwd, ignore: exclude, absolute: true });
+  const allEntries = [];
+  for (const file of files) {
+    allEntries.push(...parseTCalls(file));
+  }
+  return allEntries;
+}
 async function parseProject(options = {}) {
   const {
     cwd = process.cwd(),
@@ -204,7 +323,66 @@ Searching for: "${query}"
 }
 
 // src/commands/validate.ts
+var import_chalk3 = __toESM(require("chalk"));
+
+// src/commands/unused.ts
 var import_chalk2 = __toESM(require("chalk"));
+var PLURAL_SUFFIXES = ["_zero", "_one", "_two", "_few", "_many", "_other"];
+async function unused(options = {}) {
+  const { cwd } = options;
+  console.log(import_chalk2.default.blue("\nDetecting unused translations...\n"));
+  const dictEntries = await extractProjectDictionaryKeys({ cwd });
+  const tCalls = await extractProjectTCalls({ cwd });
+  const usedKeys = /* @__PURE__ */ new Set();
+  for (const call of tCalls) {
+    usedKeys.add(call.key);
+    if (!call.key.includes(":")) {
+      usedKeys.add(call.key);
+    }
+  }
+  const unusedKeys = [];
+  for (const entry of dictEntries) {
+    for (const key of entry.keys) {
+      const fullKey = entry.namespace === "default" ? key : `${entry.namespace}:${key}`;
+      if (usedKeys.has(fullKey)) continue;
+      let isPluralVariant = false;
+      for (const suffix of PLURAL_SUFFIXES) {
+        if (key.endsWith(suffix)) {
+          const baseKey = key.slice(0, -suffix.length);
+          const fullBaseKey = entry.namespace === "default" ? baseKey : `${entry.namespace}:${baseKey}`;
+          if (usedKeys.has(fullBaseKey)) {
+            isPluralVariant = true;
+            break;
+          }
+        }
+      }
+      if (isPluralVariant) continue;
+      unusedKeys.push({
+        namespace: entry.namespace,
+        key: fullKey,
+        definedIn: entry.file,
+        line: entry.line
+      });
+    }
+  }
+  if (unusedKeys.length === 0) {
+    const totalKeys = dictEntries.reduce((sum, e) => sum + e.keys.length, 0);
+    console.log(import_chalk2.default.green("No unused translations found!\n"));
+    console.log(import_chalk2.default.gray(`Checked ${totalKeys} dictionary key(s) against ${tCalls.length} t() call(s)`));
+    return { unusedKeys };
+  }
+  console.log(import_chalk2.default.yellow(`Found ${unusedKeys.length} unused translation key(s):
+`));
+  for (const item of unusedKeys) {
+    const relativePath = item.definedIn.replace(process.cwd() + "/", "");
+    console.log(`  ${import_chalk2.default.red("-")} ${import_chalk2.default.cyan(item.key)}`);
+    console.log(import_chalk2.default.gray(`    defined in ${relativePath}:${item.line}`));
+  }
+  console.log();
+  return { unusedKeys };
+}
+
+// src/commands/validate.ts
 function checkVariableConsistency(entry) {
   const varsByLocale = [];
   for (const [locale, text] of Object.entries(entry.translations)) {
@@ -268,8 +446,8 @@ function checkICUTypeConsistency(entry) {
   };
 }
 async function validate(options = {}) {
-  const { cwd, locales, strict } = options;
-  console.log(import_chalk2.default.blue("\nValidating translations...\n"));
+  const { cwd, locales, strict, unused: checkUnused } = options;
+  console.log(import_chalk3.default.blue("\nValidating translations...\n"));
   const entries = await parseProject({ cwd });
   const issues = [];
   const groups = /* @__PURE__ */ new Map();
@@ -314,44 +492,53 @@ async function validate(options = {}) {
       if (issue) issues.push(issue);
     }
   }
-  if (issues.length === 0) {
-    console.log(import_chalk2.default.green("\u2705 All translations are valid!\n"));
-    console.log(import_chalk2.default.gray(`Checked ${entries.length} translation(s)`));
+  let unusedCount = 0;
+  if (checkUnused) {
+    const result = await unused({ cwd });
+    unusedCount = result.unusedKeys.length;
+  }
+  if (issues.length === 0 && unusedCount === 0) {
+    console.log(import_chalk3.default.green("All translations are valid!\n"));
+    console.log(import_chalk3.default.gray(`Checked ${entries.length} translation(s)`));
     if (strict) {
-      console.log(import_chalk2.default.gray("(strict mode enabled)"));
+      console.log(import_chalk3.default.gray("(strict mode enabled)"));
+    }
+    if (checkUnused) {
+      console.log(import_chalk3.default.gray("(unused key detection enabled)"));
     }
     return;
   }
-  console.log(import_chalk2.default.red(`\u274C Found ${issues.length} issue(s):
+  console.log(import_chalk3.default.red(`Found ${issues.length} issue(s):
 `));
   for (const issue of issues) {
-    const icon = issue.type === "inconsistent" ? "\u26A0\uFE0F" : issue.type === "missing" ? "\u{1F4ED}" : issue.type === "icu_type_mismatch" ? "\u{1F527}" : "\u{1F500}";
-    console.log(`${icon}  ${import_chalk2.default.yellow(issue.message)}`);
+    console.log(`  ${import_chalk3.default.yellow(issue.message)}`);
     for (const entry of issue.entries) {
       const relativePath = entry.file.replace(process.cwd() + "/", "");
-      console.log(import_chalk2.default.gray(`   ${relativePath}:${entry.line}`));
+      console.log(import_chalk3.default.gray(`   ${relativePath}:${entry.line}`));
       for (const [locale, text] of Object.entries(entry.translations)) {
-        console.log(`     ${import_chalk2.default.cyan(locale)}: ${text}`);
+        console.log(`     ${import_chalk3.default.cyan(locale)}: ${text}`);
       }
     }
     if (issue.details && issue.details.length > 0) {
       for (const detail of issue.details) {
-        console.log(import_chalk2.default.gray(`     \u2192 ${detail}`));
+        console.log(import_chalk3.default.gray(`     \u2192 ${detail}`));
       }
     }
     console.log();
   }
-  process.exit(1);
+  if ((issues.length > 0 || unusedCount > 0) && !options.noExit) {
+    process.exit(1);
+  }
 }
 
 // src/commands/coverage.ts
-var import_chalk3 = __toESM(require("chalk"));
+var import_chalk4 = __toESM(require("chalk"));
 async function coverage(options) {
   const { cwd, locales } = options;
-  console.log(import_chalk3.default.blue("\nAnalyzing translation coverage...\n"));
+  console.log(import_chalk4.default.blue("\nAnalyzing translation coverage...\n"));
   const entries = await parseProject({ cwd });
   if (entries.length === 0) {
-    console.log(import_chalk3.default.yellow("No translations found."));
+    console.log(import_chalk4.default.yellow("No translations found."));
     return;
   }
   const coverageData = [];
@@ -370,20 +557,20 @@ async function coverage(options) {
       percentage
     });
   }
-  console.log(import_chalk3.default.bold("Translation Coverage:\n"));
+  console.log(import_chalk4.default.bold("Translation Coverage:\n"));
   const maxLocaleLen = Math.max(...locales.map((l) => l.length), 6);
   console.log(
-    import_chalk3.default.gray(
+    import_chalk4.default.gray(
       `${"Locale".padEnd(maxLocaleLen)}  ${"Coverage".padStart(10)}  ${"Translated".padStart(12)}`
     )
   );
-  console.log(import_chalk3.default.gray("\u2500".repeat(maxLocaleLen + 26)));
+  console.log(import_chalk4.default.gray("\u2500".repeat(maxLocaleLen + 26)));
   for (const data of coverageData) {
-    const color = data.percentage === 100 ? import_chalk3.default.green : data.percentage >= 80 ? import_chalk3.default.yellow : import_chalk3.default.red;
+    const color = data.percentage === 100 ? import_chalk4.default.green : data.percentage >= 80 ? import_chalk4.default.yellow : import_chalk4.default.red;
     const bar = createProgressBar(data.percentage, 10);
     const percentStr = `${data.percentage}%`.padStart(4);
     console.log(
-      `${data.locale.padEnd(maxLocaleLen)}  ${color(bar)} ${color(percentStr)}  ${import_chalk3.default.gray(`${data.translated}/${data.total}`)}`
+      `${data.locale.padEnd(maxLocaleLen)}  ${color(bar)} ${color(percentStr)}  ${import_chalk4.default.gray(`${data.translated}/${data.total}`)}`
     );
   }
   console.log();
@@ -391,9 +578,9 @@ async function coverage(options) {
   const partiallyCovered = coverageData.filter((d) => d.percentage > 0 && d.percentage < 100).length;
   const notCovered = coverageData.filter((d) => d.percentage === 0).length;
   if (fullyCovered === locales.length) {
-    console.log(import_chalk3.default.green("\u2705 All locales are fully translated!"));
+    console.log(import_chalk4.default.green("All locales are fully translated!"));
   } else {
-    console.log(import_chalk3.default.gray(`Full: ${fullyCovered}, Partial: ${partiallyCovered}, Empty: ${notCovered}`));
+    console.log(import_chalk4.default.gray(`Full: ${fullyCovered}, Partial: ${partiallyCovered}, Empty: ${notCovered}`));
   }
 }
 function createProgressBar(percentage, width) {
@@ -402,17 +589,206 @@ function createProgressBar(percentage, width) {
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
 
+// src/commands/typegen.ts
+var fs2 = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_chalk5 = __toESM(require("chalk"));
+var PLURAL_SUFFIXES2 = ["_zero", "_one", "_two", "_few", "_many", "_other"];
+async function typegen(options = {}) {
+  const { cwd, output = "src/i18n.d.ts" } = options;
+  console.log(import_chalk5.default.blue("\nGenerating TypeScript types...\n"));
+  const dictEntries = await extractProjectDictionaryKeys({ cwd });
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const entry of dictEntries) {
+    for (const key of entry.keys) {
+      const fullKey = entry.namespace === "default" ? key : `${entry.namespace}:${key}`;
+      allKeys.add(fullKey);
+      for (const suffix of PLURAL_SUFFIXES2) {
+        if (key.endsWith(suffix)) {
+          const baseKey = key.slice(0, -suffix.length);
+          const fullBaseKey = entry.namespace === "default" ? baseKey : `${entry.namespace}:${baseKey}`;
+          allKeys.add(fullBaseKey);
+        }
+      }
+    }
+  }
+  if (allKeys.size === 0) {
+    console.log(import_chalk5.default.yellow("No dictionary keys found. Make sure loadDictionaries() calls are present."));
+    return;
+  }
+  const sortedKeys = [...allKeys].sort();
+  const keyUnion = sortedKeys.map((k) => `    | '${k}'`).join("\n");
+  const content = `// Auto-generated by inline-i18n typegen
+// Do not edit manually. Re-run: npx inline-i18n typegen
+
+import 'inline-i18n-multi'
+
+declare module 'inline-i18n-multi' {
+  export type TranslationKey =
+${keyUnion}
+
+  export function t(
+    key: TranslationKey,
+    vars?: TranslationVars,
+    locale?: string
+  ): string
+
+  export function hasTranslation(
+    key: TranslationKey,
+    locale?: string
+  ): boolean
+}
+`;
+  const outputPath = path.resolve(cwd || process.cwd(), output);
+  const outputDir = path.dirname(outputPath);
+  if (!fs2.existsSync(outputDir)) {
+    fs2.mkdirSync(outputDir, { recursive: true });
+  }
+  fs2.writeFileSync(outputPath, content, "utf-8");
+  console.log(import_chalk5.default.green(`Generated ${sortedKeys.length} translation key types`));
+  console.log(import_chalk5.default.gray(`Output: ${outputPath}
+`));
+  const sample = sortedKeys.slice(0, 5);
+  for (const key of sample) {
+    console.log(`  ${import_chalk5.default.cyan(key)}`);
+  }
+  if (sortedKeys.length > 5) {
+    console.log(import_chalk5.default.gray(`  ... and ${sortedKeys.length - 5} more`));
+  }
+}
+
+// src/commands/extract.ts
+var import_chalk6 = __toESM(require("chalk"));
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+async function extract(options = {}) {
+  const { cwd, output = "translations", format = "flat" } = options;
+  console.log(import_chalk6.default.blue("\nExtracting inline translations...\n"));
+  const entries = await parseProject({ cwd });
+  if (entries.length === 0) {
+    console.log(import_chalk6.default.yellow("No translations found."));
+    return;
+  }
+  const byLocale = {};
+  const basePath = cwd || process.cwd();
+  for (const entry of entries) {
+    for (const [locale, text] of Object.entries(entry.translations)) {
+      if (!byLocale[locale]) byLocale[locale] = {};
+      const relativePath = entry.file.replace(basePath + "/", "");
+      const key = `${relativePath}:${entry.line}`;
+      byLocale[locale][key] = text;
+    }
+  }
+  const outputDir = path2.resolve(basePath, output);
+  if (!fs3.existsSync(outputDir)) {
+    fs3.mkdirSync(outputDir, { recursive: true });
+  }
+  const locales = Object.keys(byLocale).sort();
+  for (const locale of locales) {
+    const translations = byLocale[locale];
+    let content;
+    if (format === "nested") {
+      const nested = buildNestedObject(translations);
+      content = JSON.stringify(nested, null, 2) + "\n";
+    } else {
+      content = JSON.stringify(translations, null, 2) + "\n";
+    }
+    const filePath = path2.join(outputDir, `${locale}.json`);
+    fs3.writeFileSync(filePath, content);
+    console.log(
+      import_chalk6.default.green(`  ${locale}.json`) + import_chalk6.default.gray(` (${Object.keys(translations).length} keys)`)
+    );
+  }
+  console.log(import_chalk6.default.gray(`
+Extracted ${entries.length} translation(s) to ${output}/`));
+}
+function buildNestedObject(flat) {
+  const result = {};
+  for (const [key, value] of Object.entries(flat)) {
+    const parts = key.split(".");
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!current[part] || typeof current[part] !== "object") {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+
+// src/watch.ts
+var import_chokidar = require("chokidar");
+var import_chalk7 = __toESM(require("chalk"));
+function startWatch(options) {
+  const { cwd, patterns, ignore, onChange, label } = options;
+  console.log(import_chalk7.default.blue(`
+Watching for changes (${label})...
+`));
+  console.log(import_chalk7.default.gray("Press Ctrl+C to stop\n"));
+  const watcher = (0, import_chokidar.watch)(patterns, {
+    cwd,
+    ignored: ignore,
+    ignoreInitial: true
+  });
+  let debounceTimer = null;
+  const handleChange = (filePath) => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      console.log(import_chalk7.default.gray(`
+Change detected: ${filePath}`));
+      console.log(import_chalk7.default.gray("-".repeat(40)));
+      try {
+        await onChange();
+      } catch {
+      }
+      console.log(import_chalk7.default.gray(`
+Watching for changes (${label})...`));
+    }, 300);
+  };
+  watcher.on("change", handleChange);
+  watcher.on("add", handleChange);
+}
+
 // src/bin.ts
 var program = new import_commander.Command();
-program.name("inline-i18n").description("CLI tools for inline-i18n-multi").version("0.7.0");
+program.name("inline-i18n").description("CLI tools for inline-i18n-multi").version("0.9.0");
 program.command("find <query>").description("Find translations containing the query text").option("-c, --cwd <path>", "Working directory").action(async (query, options) => {
   await find({ query, cwd: options.cwd });
 });
-program.command("validate").description("Validate translation consistency").option("-c, --cwd <path>", "Working directory").option("-l, --locales <locales...>", "Required locales to check").option("-s, --strict", "Enable strict mode (ICU type consistency check)").action(async (options) => {
-  await validate(options);
+program.command("validate").description("Validate translation consistency").option("-c, --cwd <path>", "Working directory").option("-l, --locales <locales...>", "Required locales to check").option("-s, --strict", "Enable strict mode (ICU type consistency check)").option("-u, --unused", "Detect unused dictionary keys").option("-w, --watch", "Watch mode - re-validate on file changes").action(async (options) => {
+  await validate(options.watch ? { ...options, noExit: true } : options);
+  if (options.watch) {
+    const cwd = options.cwd || process.cwd();
+    startWatch({
+      cwd,
+      patterns: ["**/*.{ts,tsx,js,jsx}"],
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**"],
+      onChange: () => validate({ ...options, noExit: true }),
+      label: "validate"
+    });
+  }
 });
 program.command("coverage").description("Show translation coverage by locale").option("-c, --cwd <path>", "Working directory").option("-l, --locales <locales...>", "Locales to check", ["ko", "en"]).action(async (options) => {
   await coverage(options);
 });
+program.command("typegen").description("Generate TypeScript types for translation keys").option("-c, --cwd <path>", "Working directory").option("-o, --output <path>", "Output file path", "src/i18n.d.ts").option("-w, --watch", "Watch mode - regenerate types on file changes").action(async (options) => {
+  await typegen(options);
+  if (options.watch) {
+    const cwd = options.cwd || process.cwd();
+    startWatch({
+      cwd,
+      patterns: ["**/*.{ts,tsx,js,jsx}"],
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**"],
+      onChange: () => typegen(options),
+      label: "typegen"
+    });
+  }
+});
+program.command("extract").description("Extract inline translations to JSON files").option("-c, --cwd <path>", "Working directory").option("-o, --output <path>", "Output directory", "translations").option("-f, --format <format>", "Output format (flat|nested)", "flat").action(async (options) => {
+  await extract(options);
+});
 program.parse();
 //# sourceMappingURL=bin.js.map