@abdess76/i18nkit 1.0.0

package/bin/core/context.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const { loadConfig } = require('./config');
+const { parseArgs, detectCommand } = require('./args');
+const { resolvePaths } = require('./paths');
+const { loadPlugins } = require('./plugin-resolver');
+
+/**
+ * @typedef {Object} Context
+ * @property {string[]} args
+ * @property {Object} config
+ * @property {string} cwd
+ * @property {Object} exitCodes
+ * @property {boolean} verbose
+ * @property {boolean} jsonOutput
+ * @property {boolean} strict
+ * @property {boolean} dryRun
+ * @property {boolean} ciMode
+ * @property {boolean} useDeepL
+ * @property {string} srcDir
+ * @property {string} i18nDir
+ * @property {string} reportDir
+ * @property {string} backupDir
+ * @property {string|null} lang
+ * @property {string} format
+ * @property {string} outputFile
+ * @property {string} keyMappingFile
+ * @property {string[]} excludedFolders
+ * @property {boolean} merge
+ * @property {boolean} skipTranslated
+ * @property {boolean} extractTsObjects
+ * @property {boolean} autoApply
+ * @property {string[]} initLangs
+ * @property {boolean} backup
+ * @property {boolean} interactive
+ * @property {string|null} translatePair
+ * @property {string|null} translateEmail
+ * @property {Array} parsers
+ * @property {Object} adapter
+ * @property {Object} provider
+ * @property {function} log
+ */
+
+const EXIT_CODES = Object.freeze({
+  SUCCESS: 0,
+  UNTRANSLATED: 1,
+  ERROR: 2,
+});
+
+/**
+ * Create execution context from command line args
+ * @param {string[]} [args]
+ * @param {string} [cwd]
+ * @returns {Context}
+ */
+function buildPluginConfig(config, flags) {
+  const provider =
+    flags.useDeepL ? '@i18nkit/provider-deepl' : config.provider || '@i18nkit/provider-mymemory';
+  return { ...config, provider };
+}
+
+function createContext(args = process.argv.slice(2), cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  const flags = parseArgs(args, config);
+  const paths = resolvePaths({ args, config, cwd, lang: flags.lang });
+  const { parsers, adapter, provider } = loadPlugins(buildPluginConfig(config, flags), cwd);
+  const log = (...msgs) => !flags.jsonOutput && console.log(...msgs);
+  return {
+    args,
+    config,
+    cwd,
+    exitCodes: EXIT_CODES,
+    ...flags,
+    ...paths,
+    parsers,
+    adapter,
+    provider,
+    log,
+  };
+}
+
+module.exports = {
+  createContext,
+  detectCommand,
+  EXIT_CODES,
+};

package/bin/core/detector.js

@@ -0,0 +1,152 @@
+'use strict';
+
+/**
+ * @fileoverview Auto-detection of frontend frameworks, UI libraries, and i18n solutions.
+ * Analyzes package.json dependencies and root files to identify project stack.
+ * @module detector
+ */
+
+const fs = require('./fs-adapter');
+const path = require('path');
+
+const stripVersion = v => v?.replace(/[\^~]/, '');
+const getDep = (ctx, pkg) => ctx.pkg.dependencies?.[pkg];
+const getVersion = pkg => ctx => stripVersion(getDep(ctx, pkg));
+
+const DETECTION_RULES = [
+  {
+    id: 'angular',
+    type: 'framework',
+    detect: ctx => getDep(ctx, '@angular/core') || ctx.files.includes('angular.json'),
+    plugins: ['parser-angular'],
+    label: 'Angular',
+    version: getVersion('@angular/core'),
+  },
+  {
+    id: 'react',
+    type: 'framework',
+    detect: ctx => getDep(ctx, 'react'),
+    plugins: ['parser-react'],
+    label: 'React',
+    version: getVersion('react'),
+  },
+  {
+    id: 'vue',
+    type: 'framework',
+    detect: ctx => getDep(ctx, 'vue'),
+    plugins: ['parser-vue'],
+    label: 'Vue',
+    version: getVersion('vue'),
+  },
+  {
+    id: 'primeng',
+    type: 'library',
+    detect: ctx => getDep(ctx, 'primeng'),
+    plugins: ['parser-primeng'],
+    label: 'PrimeNG',
+    version: getVersion('primeng'),
+  },
+  {
+    id: 'material',
+    type: 'library',
+    detect: ctx => getDep(ctx, '@angular/material'),
+    plugins: ['parser-material'],
+    label: 'Angular Material',
+    version: getVersion('@angular/material'),
+  },
+  {
+    id: 'transloco',
+    type: 'i18n',
+    detect: ctx => getDep(ctx, '@jsverse/transloco') || getDep(ctx, '@ngneat/transloco'),
+    plugins: ['adapter-transloco'],
+    label: 'Transloco',
+    version: ctx =>
+      stripVersion(getDep(ctx, '@jsverse/transloco') || getDep(ctx, '@ngneat/transloco')),
+  },
+  {
+    id: 'ngx-translate',
+    type: 'i18n',
+    detect: ctx => getDep(ctx, '@ngx-translate/core'),
+    plugins: ['adapter-ngx-translate'],
+    label: 'ngx-translate',
+    version: getVersion('@ngx-translate/core'),
+  },
+  {
+    id: 'react-i18next',
+    type: 'i18n',
+    detect: ctx => getDep(ctx, 'react-i18next'),
+    plugins: ['adapter-react-i18next'],
+    label: 'react-i18next',
+    version: getVersion('react-i18next'),
+  },
+];
+
+function readPackageJson(cwd) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function listRootFiles(cwd) {
+  try {
+    return fs.readdirSync(cwd);
+  } catch {
+    return [];
+  }
+}
+
+function createEmptyDetected() {
+  return { framework: null, libraries: [], i18n: null, plugins: new Set(), details: [] };
+}
+
+function buildDetail(rule, context) {
+  const version = typeof rule.version === 'function' ? rule.version(context) : null;
+  return { id: rule.id, label: rule.label, type: rule.type, version };
+}
+
+function applyRuleToDetected(rule, detail, detected) {
+  detected.details.push(detail);
+  rule.plugins.forEach(p => detected.plugins.add(p));
+  if (rule.type === 'framework') {
+    detected.framework = detail;
+  }
+  if (rule.type === 'library') {
+    detected.libraries.push(detail);
+  }
+  if (rule.type === 'i18n') {
+    detected.i18n = detail;
+  }
+}
+
+function processDetectionRule(rule, context, detected) {
+  if (!rule.detect(context)) {
+    return;
+  }
+  applyRuleToDetected(rule, buildDetail(rule, context), detected);
+}
+
+/**
+ * Detects framework, libraries, and i18n setup from package.json
+ * @param {string} [cwd=process.cwd()]
+ * @returns {DetectionResult}
+ * @example
+ * const result = detectProject('/path/to/project');
+ * // { framework: { id: 'angular', label: 'Angular', version: '17.0.0' }, ... }
+ */
+function detectProject(cwd = process.cwd()) {
+  const context = { pkg: readPackageJson(cwd), files: listRootFiles(cwd), cwd };
+  const detected = createEmptyDetected();
+  DETECTION_RULES.forEach(rule => processDetectionRule(rule, context, detected));
+  detected.plugins = [...detected.plugins];
+  return detected;
+}
+
+module.exports = {
+  detectProject,
+};

package/bin/core/file-walker.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * @fileoverview Recursive directory walker for Angular/TypeScript projects.
+ * Filters source files, extracts inline templates, and loads external templates.
+ * @module file-walker
+ */
+
+const fs = require('./fs-adapter');
+const path = require('path');
+
+const DEFAULT_EXCLUDED_FOLDERS = ['node_modules', 'dist', '.git', 'coverage', 'e2e', '.angular'];
+
+const VALID_SOURCE_RE = /\.(ts|html)$/;
+const EXCLUDED_SOURCE_RE = /\.(spec|test|e2e|mock)\./;
+
+const isValidSourceFile = file => VALID_SOURCE_RE.test(file) && !EXCLUDED_SOURCE_RE.test(file);
+
+function validateDir(dir) {
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Directory not found: ${dir}`);
+  }
+}
+
+function shouldSkipEntry(entry, excludedFolders) {
+  return excludedFolders.includes(entry.name);
+}
+
+async function* processEntry(entry, dir, excludedFolders) {
+  const filePath = path.join(dir, entry.name);
+  if (entry.isDirectory()) {
+    yield* walkDirAsync(filePath, excludedFolders);
+  } else if (isValidSourceFile(entry.name)) {
+    yield filePath;
+  }
+}
+
+async function* walkDirAsync(dir, excludedFolders = DEFAULT_EXCLUDED_FOLDERS) {
+  validateDir(dir);
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry, excludedFolders)) {
+      continue;
+    }
+    yield* processEntry(entry, dir, excludedFolders);
+  }
+}
+
+/**
+ * Collects all .ts/.html files recursively, excluding test files
+ * @param {string} dir
+ * @param {string[]} [excludedFolders]
+ * @returns {Promise<string[]>}
+ */
+const collectFiles = (dir, excludedFolders) => Array.fromAsync(walkDirAsync(dir, excludedFolders));
+
+function readFileContent(filePath, verbose = false) {
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    if (verbose) {
+      console.warn(`Warning: Cannot read ${filePath}`);
+    }
+    return null;
+  }
+}
+
+function processTypeScriptFile(content, filePath, ctx) {
+  const hasComponent = /@Component\s*\(/.test(content);
+  if (!hasComponent) {
+    return { template: null, typescript: content, type: 'component' };
+  }
+  const { template: inlineTemplate, tsCode } = extractInlineTemplate(content);
+  const template = inlineTemplate || loadExternalTemplate(content, filePath, ctx);
+  if (!template && !tsCode) {
+    return null;
+  }
+  return { template, typescript: tsCode, type: 'component' };
+}
+
+/**
+ * Extracts template and TypeScript content from a file
+ * @param {string} filePath
+ * @param {Set<string>} processedTemplates - Tracks processed templates to avoid duplicates
+ * @param {boolean} [verbose=false]
+ * @returns {FileContent|null}
+ */
+function getFileContent(filePath, processedTemplates, verbose = false) {
+  const content = readFileContent(filePath, verbose);
+  if (!content) {
+    return null;
+  }
+  const ext = path.extname(filePath);
+  if (ext === '.html') {
+    return handleHtmlFile(content, filePath, processedTemplates);
+  }
+  if (ext !== '.ts') {
+    return null;
+  }
+  return processTypeScriptFile(content, filePath, { processedTemplates, verbose });
+}
+
+function handleHtmlFile(content, filePath, processedTemplates) {
+  const normalizedPath = path.resolve(filePath);
+  if (processedTemplates.has(normalizedPath)) {
+    return null;
+  }
+  processedTemplates.add(normalizedPath);
+  return { template: content, typescript: null, type: 'html' };
+}
+
+function extractInlineTemplate(content) {
+  const templateMatches = [...content.matchAll(/template\s*:\s*`([\s\S]*?)`/g)];
+  if (templateMatches.length === 0) {
+    return { template: null, tsCode: content };
+  }
+  const template = templateMatches.map(m => m[1]).join('\n');
+  let tsCode = content;
+  for (const m of templateMatches) {
+    tsCode = tsCode.replace(m[0], '');
+  }
+  return { template, tsCode };
+}
+
+function resolveTemplatePath(content, filePath) {
+  const urlMatch = content.match(/templateUrl\s*:\s*['"`]([^'"`]+)['"`]/);
+  return urlMatch ? path.resolve(path.dirname(filePath), urlMatch[1]) : null;
+}
+
+function isTemplateInvalid(templatePath, processedTemplates) {
+  return !templatePath || !fs.existsSync(templatePath) || processedTemplates.has(templatePath);
+}
+
+function tryReadTemplate(templatePath, verbose) {
+  try {
+    return fs.readFileSync(templatePath, 'utf-8');
+  } catch {
+    if (verbose) {
+      console.warn(`Warning: Cannot read template ${templatePath}`);
+    }
+    return null;
+  }
+}
+
+function loadExternalTemplate(content, filePath, ctx) {
+  const { processedTemplates, verbose = false } = ctx;
+  const templatePath = resolveTemplatePath(content, filePath);
+  if (isTemplateInvalid(templatePath, processedTemplates)) {
+    return null;
+  }
+  processedTemplates.add(templatePath);
+  return tryReadTemplate(templatePath, verbose);
+}
+
+module.exports = {
+  DEFAULT_EXCLUDED_FOLDERS,
+  collectFiles,
+  getFileContent,
+};

package/bin/core/fs-adapter.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * @fileoverview Filesystem abstraction layer for dependency injection.
+ * Enables mocking in tests without monkey-patching Node.js fs module.
+ * @module fs-adapter
+ */
+
+const nodeFs = require('fs');
+const nodeFsp = nodeFs.promises;
+
+let fs = nodeFs;
+let fsp = nodeFsp;
+
+/**
+ * Injects custom fs implementation for testing
+ * @param {FsAdapter} adapter
+ */
+const setAdapter = adapter => {
+  fs = adapter.fs || nodeFs;
+  fsp = adapter.fsp || nodeFsp;
+};
+
+const resetAdapter = () => {
+  fs = nodeFs;
+  fsp = nodeFsp;
+};
+
+const existsSync = path => fs.existsSync(path);
+const readFileSync = (path, encoding = 'utf-8') => fs.readFileSync(path, encoding);
+const writeFileSync = (path, data, encoding = 'utf-8') => fs.writeFileSync(path, data, encoding);
+const readdirSync = (path, options) => fs.readdirSync(path, options);
+const statSync = path => fs.statSync(path);
+const watch = (path, options, listener) => fs.watch(path, options, listener);
+const mkdirSync = (path, options) => fs.mkdirSync(path, options);
+
+const readFile = (path, encoding = 'utf-8') => fsp.readFile(path, encoding);
+const writeFile = (path, data, encoding = 'utf-8') => fsp.writeFile(path, data, encoding);
+const readdir = (path, options) => fsp.readdir(path, options);
+const mkdir = (path, options) => fsp.mkdir(path, options);
+
+module.exports = {
+  setAdapter,
+  resetAdapter,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  mkdirSync,
+  statSync,
+  watch,
+  readFile,
+  writeFile,
+  readdir,
+  mkdir,
+};

package/bin/core/help-generator.js

@@ -0,0 +1,208 @@
+'use strict';
+
+/**
+ * @fileoverview CLI help text generator.
+ * Builds formatted help output from commands, plugins, and detection results.
+ * @module help-generator
+ */
+
+const { formatPluginHelp } = require('./plugin-interface');
+const {
+  formatCommandHelp,
+  groupCommandsByCategory,
+  COMMAND_CATEGORIES,
+} = require('./command-interface');
+
+function generateHeader(packageInfo) {
+  const {
+    name = 'i18nkit',
+    version = '1.0.0',
+    description = 'Universal i18n CLI',
+  } = packageInfo || {};
+  return `${name} v${version}\n${description}`;
+}
+
+function generateUsage() {
+  return `USAGE:
+  i18nkit [command] [options]
+  i18nkit --extract [options]`;
+}
+
+function hasDetection(detected) {
+  return detected.framework || detected.libraries?.length > 0 || detected.i18n;
+}
+
+function formatVersionLabel(item) {
+  return `${item.label}${item.version ? ` v${item.version}` : ''}`;
+}
+
+function addDetectedLine(lines, label, value) {
+  if (value) {
+    lines.push(`  ${label}: ${value}`);
+  }
+}
+
+function formatLibraries(detected) {
+  return detected.libraries?.length > 0 ?
+      detected.libraries.map(formatVersionLabel).join(', ')
+    : null;
+}
+
+function formatAutoActivated(detected) {
+  return detected.plugins?.length > 0 ? detected.plugins.join(', ') : null;
+}
+
+function generateDetectedSection(detected) {
+  const lines = ['DETECTED PROJECT:'];
+  addDetectedLine(lines, 'Framework', detected.framework && formatVersionLabel(detected.framework));
+  addDetectedLine(lines, 'Libraries', formatLibraries(detected));
+  addDetectedLine(lines, 'i18n', detected.i18n && formatVersionLabel(detected.i18n));
+  addDetectedLine(lines, 'Auto-activated', formatAutoActivated(detected));
+  return lines.join('\n');
+}
+
+function generateCommandsSection(commands) {
+  const lines = ['COMMANDS:'];
+  const grouped = groupCommandsByCategory(commands);
+
+  for (const cat of COMMAND_CATEGORIES) {
+    const catCommands = grouped[cat.id]?.commands || [];
+    if (catCommands.length === 0) {
+      continue;
+    }
+    lines.push(`\n  ${cat.label}:`);
+    catCommands.forEach(cmd => lines.push(formatCommandHelp(cmd)));
+  }
+
+  return lines.join('\n');
+}
+
+function generateGlobalOptions() {
+  return `GLOBAL OPTIONS:
+  --config <path>         Path to config file (default: i18nkit.config.js)
+  --src <dir>             Source directory (default: src)
+  --locales <dir>         Locales directory (default: src/assets/i18n)
+  --default-lang <code>   Default language (default: fr)
+  --dry-run               Preview changes without writing
+  --verbose               Verbose output
+  --help, -h              Show this help
+  --version, -v           Show version`;
+}
+
+function formatPluginsByType(plugins, type, label) {
+  const items = plugins[type] || [];
+  if (items.length === 0) {
+    return [];
+  }
+  return [`\n  ${label}:`, ...items.map(formatPluginHelp)];
+}
+
+function getPluginCount(plugins, type) {
+  return plugins[type]?.length || 0;
+}
+
+function countPlugins(plugins) {
+  return (
+    getPluginCount(plugins, 'parsers') +
+    getPluginCount(plugins, 'adapters') +
+    getPluginCount(plugins, 'providers')
+  );
+}
+
+function generatePluginsSection(plugins) {
+  const lines = ['PLUGINS:'];
+  lines.push(
+    ...formatPluginsByType(plugins, 'parsers', 'PARSERS (extract i18n from source files)'),
+  );
+  lines.push(...formatPluginsByType(plugins, 'adapters', 'ADAPTERS (i18n library integration)'));
+  lines.push(...formatPluginsByType(plugins, 'providers', 'PROVIDERS (translation services)'));
+  if (countPlugins(plugins) === 0) {
+    lines.push('  No plugins loaded');
+  }
+  return lines.join('\n');
+}
+
+function collectPluginExamples(plugins) {
+  if (!plugins) {
+    return [];
+  }
+  const all = [
+    ...(plugins.parsers || []),
+    ...(plugins.adapters || []),
+    ...(plugins.providers || []),
+  ];
+  return all.flatMap(p => p.examples || []);
+}
+
+function generateExamplesSection(plugins) {
+  const lines = [
+    'EXAMPLES:',
+    '  # Extract i18n keys from Angular project',
+    '  i18nkit --extract',
+    '',
+    '  # Check translation sync',
+    '  i18nkit check-sync --strict',
+    '',
+    '  # Find orphan keys',
+    '  i18nkit find-orphans',
+    '',
+    '  # Translate to English',
+    '  i18nkit translate fr:en',
+  ];
+
+  const pluginExamples = collectPluginExamples(plugins);
+  if (pluginExamples.length > 0) {
+    lines.push('', '  # Plugin examples:');
+    pluginExamples.slice(0, 3).forEach(ex => lines.push(`  ${ex}`));
+  }
+
+  return lines.join('\n');
+}
+
+function generateFooter() {
+  return `DOCUMENTATION:
+  https://github.com/Abdess/i18nkit
+
+PLUGIN LOCATIONS:
+  builtin:  <package>/bin/plugins/
+  local:    .i18n/plugins/
+  npm:      i18nkit-* packages`;
+}
+
+function addDetectedIfPresent(sections, detected) {
+  if (detected && hasDetection(detected)) {
+    sections.push(generateDetectedSection(detected));
+  }
+}
+
+function addCommandsIfPresent(sections, commands) {
+  if (commands?.length > 0) {
+    sections.push(generateCommandsSection(commands));
+  }
+}
+
+function buildHelpSections(config) {
+  const { plugins, commands, detected, packageInfo } = config;
+  const sections = [generateHeader(packageInfo), generateUsage()];
+  addDetectedIfPresent(sections, detected);
+  addCommandsIfPresent(sections, commands);
+  sections.push(generateGlobalOptions());
+  if (plugins) {
+    sections.push(generatePluginsSection(plugins));
+  }
+  return sections;
+}
+
+/**
+ * Generates complete CLI help text with all sections
+ * @param {Object} config
+ * @returns {string}
+ */
+function generateFullHelp(config) {
+  const sections = buildHelpSections(config);
+  sections.push(generateExamplesSection(config.plugins));
+  sections.push(generateFooter());
+  return sections.join('\n\n');
+}
+
+module.exports = { generateFullHelp };