@red-hat-developer-hub/translations-cli 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @red-hat-developer-hub/translations-cli
+
+## 0.0.1
+
+### Patch Changes
+
+- 8ada47f: Initial version of the RHDH translations-cli.

package/bin/translations-cli

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/*
+ * Copyright Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const path = require('node:path');
+
+// Figure out whether we're running inside the backstage repo or as an installed dependency
+/* eslint-disable-next-line no-restricted-syntax */
+const isLocal = require('fs').existsSync(path.resolve(__dirname, '../src'));
+const hasDist = require('fs').existsSync(path.resolve(__dirname, '../dist/index.cjs.js'));
+
+// Prefer built version if available, otherwise use source with transform
+if (hasDist) {
+  require('..');
+} else if (isLocal) {
+  require('@backstage/cli/config/nodeTransform.cjs');
+  require('../src');
+} else {
+  require('..');
+}
+

package/dist/commands/clean.cjs.js

@@ -0,0 +1,130 @@
+'use strict';
+
+var path = require('node:path');
+var chalk = require('chalk');
+var fs = require('fs-extra');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function findI18nTempFiles(i18nDir) {
+  if (!await fs__default.default.pathExists(i18nDir)) {
+    return [];
+  }
+  const files = await fs__default.default.readdir(i18nDir);
+  return files.filter(
+    (file) => file.startsWith(".") || file.endsWith(".tmp") || file.endsWith(".cache")
+  );
+}
+async function collectCleanupTasks(i18nDir, cacheDir, backupDir) {
+  const [i18nTempFiles, cacheExists, backupExists] = await Promise.all([
+    findI18nTempFiles(i18nDir),
+    fs__default.default.pathExists(cacheDir),
+    fs__default.default.pathExists(backupDir)
+  ]);
+  const taskPromises = [
+    Promise.resolve(
+      i18nTempFiles.length > 0 ? {
+        name: "i18n directory",
+        path: i18nDir,
+        files: i18nTempFiles
+      } : null
+    ),
+    cacheExists ? fs__default.default.readdir(cacheDir).then((files) => ({
+      name: "cache directory",
+      path: cacheDir,
+      files
+    })) : Promise.resolve(null),
+    backupExists ? fs__default.default.readdir(backupDir).then((files) => ({
+      name: "backup directory",
+      path: backupDir,
+      files
+    })) : Promise.resolve(null)
+  ];
+  const tasks = await Promise.all(taskPromises);
+  return tasks.filter((task) => task !== null);
+}
+function displayCleanupPreview(cleanupTasks) {
+  console.log(chalk__default.default.yellow("\u{1F4CB} Files to be cleaned:"));
+  for (const task of cleanupTasks) {
+    console.log(chalk__default.default.gray(`   ${task.name}: ${task.files.length} files`));
+    for (const file of task.files) {
+      console.log(chalk__default.default.gray(`     - ${file}`));
+    }
+  }
+}
+async function performCleanup(cleanupTasks) {
+  let totalCleaned = 0;
+  for (const task of cleanupTasks) {
+    console.log(chalk__default.default.yellow(`\u{1F9F9} Cleaning ${task.name}...`));
+    for (const file of task.files) {
+      const filePath = path__default.default.join(task.path, file);
+      try {
+        await fs__default.default.remove(filePath);
+        totalCleaned++;
+      } catch (error) {
+        console.warn(
+          chalk__default.default.yellow(`\u26A0\uFE0F  Could not remove ${filePath}: ${error}`)
+        );
+      }
+    }
+  }
+  return totalCleaned;
+}
+async function removeEmptyDirectories(cleanupTasks) {
+  for (const task of cleanupTasks) {
+    const remainingFiles = await fs__default.default.readdir(task.path).catch(() => []);
+    if (remainingFiles.length === 0) {
+      try {
+        await fs__default.default.remove(task.path);
+        console.log(chalk__default.default.gray(`   Removed empty directory: ${task.path}`));
+      } catch {
+      }
+    }
+  }
+}
+function displaySummary(totalCleaned, directoriesProcessed) {
+  console.log(chalk__default.default.green(`\u2705 Cleanup completed successfully!`));
+  console.log(chalk__default.default.gray(`   Files cleaned: ${totalCleaned}`));
+  console.log(chalk__default.default.gray(`   Directories processed: ${directoriesProcessed}`));
+}
+async function cleanCommand(opts) {
+  console.log(chalk__default.default.blue("\u{1F9F9} Cleaning up temporary i18n files and caches..."));
+  const {
+    i18nDir = "i18n",
+    cacheDir = ".i18n-cache",
+    backupDir = ".i18n-backup",
+    force = false
+  } = opts;
+  try {
+    const cleanupTasks = await collectCleanupTasks(
+      i18nDir,
+      cacheDir,
+      backupDir
+    );
+    if (cleanupTasks.length === 0) {
+      console.log(chalk__default.default.yellow("\u2728 No temporary files found to clean"));
+      return;
+    }
+    displayCleanupPreview(cleanupTasks);
+    if (force) {
+      const totalCleaned = await performCleanup(cleanupTasks);
+      await removeEmptyDirectories(cleanupTasks);
+      displaySummary(totalCleaned, cleanupTasks.length);
+    } else {
+      console.log(
+        chalk__default.default.yellow("\u26A0\uFE0F  This will permanently delete the above files.")
+      );
+      console.log(chalk__default.default.yellow("   Use --force to skip this confirmation."));
+    }
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error during cleanup:"), error);
+    throw error;
+  }
+}
+
+exports.cleanCommand = cleanCommand;
+//# sourceMappingURL=clean.cjs.js.map

package/dist/commands/deploy.cjs.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var deployTranslations = require('../lib/i18n/deployTranslations.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function deployCommand(opts) {
+  console.log(
+    chalk__default.default.blue(
+      "\u{1F680} Deploying translated strings to application language files..."
+    )
+  );
+  const { sourceDir = "i18n/downloads" } = opts;
+  try {
+    const sourceDirStr = String(sourceDir || "i18n/downloads");
+    const repoRoot = process.cwd();
+    if (!await fs__default.default.pathExists(sourceDirStr)) {
+      throw new Error(`Source directory not found: ${sourceDirStr}`);
+    }
+    const files = await fs__default.default.readdir(sourceDirStr);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    if (jsonFiles.length === 0) {
+      console.log(
+        chalk__default.default.yellow(`\u26A0\uFE0F  No translation JSON files found in ${sourceDirStr}`)
+      );
+      console.log(
+        chalk__default.default.gray(
+          "   Make sure you have downloaded translations first using:"
+        )
+      );
+      console.log(chalk__default.default.gray("   translations-cli i18n download"));
+      return;
+    }
+    console.log(
+      chalk__default.default.yellow(
+        `\u{1F4C1} Found ${jsonFiles.length} translation file(s) to deploy`
+      )
+    );
+    await deployTranslations.deployTranslations(sourceDirStr, repoRoot);
+    console.log(chalk__default.default.green(`\u2705 Deployment completed successfully!`));
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error deploying translations:"), error.message);
+    throw error;
+  }
+}
+
+exports.deployCommand = deployCommand;
+//# sourceMappingURL=deploy.cjs.js.map

package/dist/commands/download.cjs.js

@@ -0,0 +1,304 @@
+'use strict';
+
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var path = require('node:path');
+var config = require('../lib/i18n/config.cjs.js');
+var exec = require('../lib/utils/exec.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+function buildDownloadJobArgs(projectId, jobId, outputDir) {
+  return [
+    "job",
+    "download",
+    "--project-id",
+    projectId,
+    "--job-id",
+    jobId,
+    "--type",
+    "target",
+    "--output-dir",
+    outputDir
+  ];
+}
+function buildListJobsArgs(projectId) {
+  return ["job", "list", "--project-id", projectId, "--format", "json"];
+}
+function findDownloadedFile(outputDir, targetLang) {
+  try {
+    const files = fs__default.default.readdirSync(outputDir);
+    const langPattern = new RegExp(`-${targetLang}(?:-C)?\\.json$`, "i");
+    const matchingFiles = files.filter((f) => langPattern.test(f));
+    if (matchingFiles.length > 0) {
+      const fileStats = matchingFiles.map((f) => ({
+        name: f,
+        mtime: fs__default.default.statSync(path__default.default.join(outputDir, f)).mtime.getTime()
+      }));
+      fileStats.sort((a, b) => b.mtime - a.mtime);
+      return fileStats[0].name;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function renameDownloadedFile(outputDir, originalFilename, targetLang) {
+  try {
+    const originalPath = path__default.default.join(outputDir, originalFilename);
+    if (!fs__default.default.existsSync(originalPath)) {
+      const foundFile = findDownloadedFile(outputDir, targetLang);
+      if (foundFile) {
+        return renameDownloadedFile(outputDir, foundFile, targetLang);
+      }
+      return null;
+    }
+    let cleanFilename = null;
+    const pattern1 = originalFilename.match(
+      /^([a-z-]+)-(\d{4}-\d{2}-\d{2})-([a-z]{2})-([a-z]{2})(?:-C)?\.json$/i
+    );
+    if (pattern1) {
+      const [, repo, date] = pattern1;
+      cleanFilename = `${repo}-${date}-${targetLang}.json`;
+    } else {
+      const pattern2 = originalFilename.match(
+        /^([a-z-]+)-reference-(\d{4}-\d{2}-\d{2})-([a-z]{2})-([a-z]{2})(?:-C)?\.json$/i
+      );
+      if (pattern2) {
+        const [, repo, date] = pattern2;
+        cleanFilename = `${repo}-${date}-${targetLang}.json`;
+      }
+    }
+    if (!cleanFilename) {
+      return originalFilename;
+    }
+    const cleanPath = path__default.default.join(outputDir, cleanFilename);
+    if (originalPath !== cleanPath) {
+      fs__default.default.moveSync(originalPath, cleanPath, { overwrite: true });
+    }
+    return cleanFilename;
+  } catch (error) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Warning: Could not rename file ${originalFilename}: ${error.message}`
+      )
+    );
+    return originalFilename;
+  }
+}
+async function downloadJob(projectId, jobId, outputDir) {
+  try {
+    const cmdArgs = buildDownloadJobArgs(projectId, jobId, outputDir);
+    exec.safeExecSyncOrThrow("memsource", cmdArgs, {
+      stdio: "pipe",
+      env: { ...process.env }
+    });
+    const jobInfoArgs = buildListJobsArgs(projectId);
+    const jobListOutput = exec.safeExecSyncOrThrow("memsource", jobInfoArgs, {
+      encoding: "utf-8",
+      env: { ...process.env }
+    });
+    const jobs = JSON.parse(jobListOutput);
+    const jobArray = Array.isArray(jobs) ? jobs : [jobs];
+    const job = jobArray.find((j) => j.uid === jobId);
+    if (job) {
+      const originalFilename = job.filename;
+      let actualFile = originalFilename;
+      if (!fs__default.default.existsSync(path__default.default.join(outputDir, originalFilename))) {
+        const foundFile = findDownloadedFile(outputDir, job.target_lang);
+        if (foundFile) {
+          actualFile = foundFile;
+        }
+      }
+      const cleanFilename = renameDownloadedFile(
+        outputDir,
+        actualFile,
+        job.target_lang
+      );
+      return {
+        jobId,
+        filename: cleanFilename || actualFile,
+        lang: job.target_lang
+      };
+    }
+    return null;
+  } catch (error) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Warning: Could not download job ${jobId}: ${error.message}`
+      )
+    );
+    return null;
+  }
+}
+function validateMemsourcePrerequisites() {
+  if (!exec.commandExists("memsource")) {
+    throw new Error(
+      "memsource CLI not found. Please ensure memsource-cli is installed and ~/.memsourcerc is sourced."
+    );
+  }
+  if (!process.env.MEMSOURCE_TOKEN) {
+    throw new Error(
+      "MEMSOURCE_TOKEN not found. Please source ~/.memsourcerc first: source ~/.memsourcerc"
+    );
+  }
+}
+async function downloadSpecificJobs(projectId, jobIds, outputDir) {
+  console.log(
+    chalk__default.default.yellow(`\u{1F4E5} Downloading ${jobIds.length} specific job(s)...`)
+  );
+  const downloadResults = [];
+  for (const jobId of jobIds) {
+    const result = await downloadJob(projectId, jobId, outputDir);
+    if (result) {
+      downloadResults.push(result);
+      console.log(
+        chalk__default.default.green(
+          `\u2705 Downloaded job ${result.jobId}: ${result.filename} (${result.lang})`
+        )
+      );
+    }
+  }
+  return downloadResults;
+}
+function listJobs(projectId, languages, statusFilter) {
+  const listArgs = buildListJobsArgs(projectId);
+  const listOutput = exec.safeExecSyncOrThrow("memsource", listArgs, {
+    encoding: "utf-8",
+    env: { ...process.env }
+  });
+  const jobs = JSON.parse(listOutput);
+  const jobArray = Array.isArray(jobs) ? jobs : [jobs];
+  let filteredJobs = jobArray;
+  if (statusFilter && statusFilter !== "ALL") {
+    filteredJobs = filteredJobs.filter(
+      (job) => job.status === statusFilter
+    );
+  }
+  if (languages && languages.length > 0) {
+    const languageSet = new Set(languages);
+    filteredJobs = filteredJobs.filter(
+      (job) => languageSet.has(job.target_lang)
+    );
+  }
+  return filteredJobs;
+}
+async function downloadFilteredJobs(projectId, outputDir, languages, statusFilter) {
+  console.log(chalk__default.default.yellow("\u{1F4CB} Listing available jobs..."));
+  try {
+    const jobsToDownload = listJobs(projectId, languages, statusFilter);
+    const statusDisplay = statusFilter === "ALL" ? "all statuses" : statusFilter || "COMPLETED";
+    console.log(
+      chalk__default.default.yellow(
+        `\u{1F4E5} Found ${jobsToDownload.length} job(s) with status "${statusDisplay}" to download...`
+      )
+    );
+    if (jobsToDownload.length === 0) {
+      console.log(
+        chalk__default.default.yellow(
+          '\u{1F4A1} Tip: Use "i18n list" to see all available jobs and their UIDs.'
+        )
+      );
+      return [];
+    }
+    const downloadResults = [];
+    for (const job of jobsToDownload) {
+      const result = await downloadJob(projectId, job.uid, outputDir);
+      if (result) {
+        downloadResults.push(result);
+        const statusIcon = job.status === "COMPLETED" ? "\u2705" : "\u26A0\uFE0F";
+        console.log(
+          chalk__default.default.green(
+            `${statusIcon} Downloaded: ${result.filename} (${result.lang}) [${job.status}]`
+          )
+        );
+      }
+    }
+    return downloadResults;
+  } catch (error) {
+    throw new Error(`Failed to list jobs: ${error.message}`);
+  }
+}
+async function downloadWithMemsourceCLI(projectId, outputDir, jobIds, languages, statusFilter) {
+  validateMemsourcePrerequisites();
+  await fs__default.default.ensureDir(outputDir);
+  if (jobIds && jobIds.length > 0) {
+    return downloadSpecificJobs(projectId, jobIds, outputDir);
+  }
+  return downloadFilteredJobs(projectId, outputDir, languages, statusFilter);
+}
+async function downloadCommand(opts) {
+  console.log(chalk__default.default.blue("\u{1F4E5} Downloading translated strings from TMS..."));
+  const config$1 = await config.loadI18nConfig();
+  const mergedOpts = await config.mergeConfigWithOptions(config$1, opts);
+  const {
+    projectId,
+    outputDir = "i18n/downloads",
+    languages,
+    jobIds,
+    status,
+    includeIncomplete
+  } = mergedOpts;
+  let statusFilter = status || "COMPLETED";
+  if (includeIncomplete || statusFilter === "ALL") {
+    statusFilter = "ALL";
+  }
+  if (!projectId) {
+    console.error(chalk__default.default.red("\u274C Missing required TMS configuration:"));
+    console.error("");
+    console.error(chalk__default.default.yellow("   \u2717 Project ID"));
+    console.error(
+      chalk__default.default.gray(
+        "     Set via: --project-id <id> or I18N_TMS_PROJECT_ID or .i18n.config.json"
+      )
+    );
+    console.error("");
+    console.error(chalk__default.default.blue("\u{1F4CB} Quick Setup Guide:"));
+    console.error(chalk__default.default.gray("   1. Run: translations-cli i18n init"));
+    console.error(chalk__default.default.gray("   2. Edit .i18n.config.json to add Project ID"));
+    console.error(
+      chalk__default.default.gray("   3. Source ~/.memsourcerc: source ~/.memsourcerc")
+    );
+    process.exit(1);
+  }
+  if (!process.env.MEMSOURCE_TOKEN) {
+    console.error(chalk__default.default.red("\u274C MEMSOURCE_TOKEN not found"));
+    console.error(chalk__default.default.yellow("   Please source ~/.memsourcerc first:"));
+    console.error(chalk__default.default.gray("     source ~/.memsourcerc"));
+    process.exit(1);
+  }
+  try {
+    const jobIdArray = jobIds && typeof jobIds === "string" ? jobIds.split(",").map((id) => id.trim()) : void 0;
+    const languageArray = languages && typeof languages === "string" ? languages.split(",").map((lang) => lang.trim()) : void 0;
+    const downloadResults = await downloadWithMemsourceCLI(
+      projectId,
+      String(outputDir),
+      jobIdArray,
+      languageArray,
+      statusFilter
+    );
+    console.log(chalk__default.default.green(`\u2705 Download completed successfully!`));
+    console.log(chalk__default.default.gray(`   Output directory: ${outputDir}`));
+    console.log(chalk__default.default.gray(`   Files downloaded: ${downloadResults.length}`));
+    if (downloadResults.length > 0) {
+      console.log(chalk__default.default.blue("\u{1F4C1} Downloaded files:"));
+      for (const result of downloadResults) {
+        console.log(
+          chalk__default.default.gray(
+            `   ${result.filename} (${result.lang}) - Job ID: ${result.jobId}`
+          )
+        );
+      }
+    }
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error downloading from TMS:"), error.message);
+    throw error;
+  }
+}
+
+exports.downloadCommand = downloadCommand;
+//# sourceMappingURL=download.cjs.js.map