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

package/dist/commands/setupMemsource.cjs.js

@@ -0,0 +1,338 @@
+'use strict';
+
+var path = require('node:path');
+var os = require('node:os');
+var readline = require('node:readline');
+var process$1 = require('process');
+var chalk = require('chalk');
+var fs = require('fs-extra');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var os__default = /*#__PURE__*/_interopDefaultCompat(os);
+var readline__namespace = /*#__PURE__*/_interopNamespaceCompat(readline);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function isInteractiveTerminal() {
+  return process$1.stdin.isTTY && process$1.stdout.isTTY;
+}
+async function promptUsername(rl) {
+  const question = (query) => {
+    return new Promise((resolve) => {
+      rl.question(query, resolve);
+    });
+  };
+  const username = await question(chalk__default.default.yellow("Enter Memsource username: "));
+  if (!username || username.trim() === "") {
+    rl.close();
+    throw new Error("Username is required");
+  }
+  return username;
+}
+async function promptPassword(rl) {
+  const questionPassword = (query) => {
+    return new Promise((resolve) => {
+      const wasRawMode = process$1.stdin.isRaw || false;
+      if (process$1.stdin.isTTY) {
+        process$1.stdin.setRawMode(true);
+      }
+      process$1.stdin.resume();
+      process$1.stdin.setEncoding("utf8");
+      process$1.stdout.write(query);
+      let inputPassword = "";
+      let cleanup;
+      const onData = (char) => {
+        if (char === "\r" || char === "\n") {
+          cleanup();
+          process$1.stdout.write("\n");
+          resolve(inputPassword);
+          return;
+        }
+        if (char === "") {
+          cleanup();
+          process$1.stdout.write("\n");
+          process.exit(130);
+          return;
+        }
+        if (char === "\x7F" || char === "\b" || char === "\x1B[3~") {
+          if (inputPassword.length > 0) {
+            inputPassword = inputPassword.slice(0, -1);
+            process$1.stdout.write("\b \b");
+          }
+          return;
+        }
+        if (char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127) {
+          return;
+        }
+        inputPassword += char;
+        process$1.stdout.write("*");
+      };
+      cleanup = () => {
+        process$1.stdin.removeListener("data", onData);
+        if (process$1.stdin.isTTY) {
+          process$1.stdin.setRawMode(wasRawMode);
+        }
+        process$1.stdin.pause();
+      };
+      process$1.stdin.on("data", onData);
+    });
+  };
+  const password = await questionPassword(
+    chalk__default.default.yellow("Enter Memsource password: ")
+  );
+  if (!password || password.trim() === "") {
+    rl.close();
+    throw new Error("Password is required");
+  }
+  return password;
+}
+async function promptCredentials() {
+  const rl = readline__namespace.createInterface({
+    input: process$1.stdin,
+    output: process$1.stdout
+  });
+  try {
+    const username = await promptUsername(rl);
+    const password = await promptPassword(rl);
+    return { username, password };
+  } finally {
+    rl.close();
+  }
+}
+async function getCredentials(isInteractive, noInput, username, password) {
+  if (username && password) {
+    return { username, password };
+  }
+  if (isInteractive && !noInput) {
+    const prompted = await promptCredentials();
+    return {
+      username: username || prompted.username,
+      password: password || prompted.password
+    };
+  }
+  if (!isInteractive || noInput) {
+    throw new Error(
+      "Username and password are required. Provide them via --username and --password options, or use environment variables (MEMSOURCE_USERNAME, MEMSOURCE_PASSWORD), or run in an interactive terminal to be prompted."
+    );
+  }
+  throw new Error("Username and password are required");
+}
+function generateMemsourceRcContent(memsourceVenv, memsourceUrl, username, password) {
+  return `source ${memsourceVenv}
+
+export MEMSOURCE_URL="${memsourceUrl}"
+
+export MEMSOURCE_USERNAME=${username}
+
+export MEMSOURCE_PASSWORD="${password}"
+
+export MEMSOURCE_TOKEN=$(memsource auth login --user-name $MEMSOURCE_USERNAME --password "$"MEMSOURCE_PASSWORD -c token -f value)
+`.replace('$"MEMSOURCE_PASSWORD', "${MEMSOURCE_PASSWORD}");
+}
+function displaySetupInstructions(memsourceRcPath) {
+  console.log(
+    chalk__default.default.green(`\u2705 Created .memsourcerc file at ${memsourceRcPath}`)
+  );
+  console.log(chalk__default.default.yellow("\n\u26A0\uFE0F  Security Note:"));
+  console.log(chalk__default.default.gray("   This file contains your password in plain text."));
+  console.log(
+    chalk__default.default.gray("   File permissions are set to 600 (owner read/write only).")
+  );
+  console.log(
+    chalk__default.default.gray(
+      "   Keep this file secure and never commit it to version control."
+    )
+  );
+  console.log(chalk__default.default.yellow("\n\u{1F4DD} Next steps:"));
+  console.log(chalk__default.default.gray("   1. Source the file in your shell:"));
+  console.log(chalk__default.default.cyan(`      source ~/.memsourcerc`));
+  console.log(
+    chalk__default.default.gray(
+      "   2. Or add it to your shell profile (~/.bashrc, ~/.zshrc, etc.):"
+    )
+  );
+  console.log(chalk__default.default.cyan(`      echo "source ~/.memsourcerc" >> ~/.zshrc`));
+  console.log(chalk__default.default.gray("   3. Verify the setup:"));
+  console.log(
+    chalk__default.default.cyan(`      source ~/.memsourcerc && echo $MEMSOURCE_TOKEN`)
+  );
+  console.log(
+    chalk__default.default.gray(
+      "   4. After sourcing, you can use i18n commands without additional setup"
+    )
+  );
+}
+async function detectMemsourceVenv() {
+  const homeDir = os__default.default.homedir();
+  const commonPaths = [
+    // Common installation locations
+    path__default.default.join(
+      homeDir,
+      "git",
+      "memsource-cli-client",
+      ".memsource",
+      "bin",
+      "activate"
+    ),
+    path__default.default.join(homeDir, "memsource-cli-client", ".memsource", "bin", "activate"),
+    path__default.default.join(homeDir, ".memsource", "bin", "activate"),
+    path__default.default.join(
+      homeDir,
+      ".local",
+      "memsource-cli-client",
+      ".memsource",
+      "bin",
+      "activate"
+    )
+  ];
+  for (const venvPath of commonPaths) {
+    if (venvPath && await fs__default.default.pathExists(venvPath)) {
+      return venvPath;
+    }
+  }
+  return null;
+}
+async function promptMemsourceVenv(rl) {
+  const question = (query) => {
+    return new Promise((resolve) => {
+      rl.question(query, resolve);
+    });
+  };
+  console.log(chalk__default.default.yellow("\n\u{1F4C1} Memsource CLI Virtual Environment Path"));
+  console.log(
+    chalk__default.default.gray("   The memsource CLI requires a Python virtual environment.")
+  );
+  console.log(chalk__default.default.gray("   Common locations:"));
+  console.log(
+    chalk__default.default.gray("     - ~/git/memsource-cli-client/.memsource/bin/activate")
+  );
+  console.log(
+    chalk__default.default.gray("     - ~/memsource-cli-client/.memsource/bin/activate")
+  );
+  console.log(chalk__default.default.gray("     - ~/.memsource/bin/activate"));
+  console.log(
+    chalk__default.default.gray(
+      "   Or wherever you installed the memsource-cli-client repository.\n"
+    )
+  );
+  const venvPath = await question(
+    chalk__default.default.yellow("Enter path to memsource venv activate script: ")
+  );
+  if (!venvPath || venvPath.trim() === "") {
+    rl.close();
+    throw new Error("Virtual environment path is required");
+  }
+  return venvPath.trim();
+}
+async function getMemsourceVenv(providedPath, isInteractive, noInput) {
+  if (providedPath) {
+    return providedPath;
+  }
+  const detectedPath = await detectMemsourceVenv();
+  if (detectedPath) {
+    console.log(
+      chalk__default.default.gray(
+        `   Detected memsource venv at: ${detectedPath.replace(
+          os__default.default.homedir(),
+          "~"
+        )}`
+      )
+    );
+    return detectedPath;
+  }
+  if (isInteractive && !noInput) {
+    const rl = readline__namespace.createInterface({
+      input: process$1.stdin,
+      output: process$1.stdout
+    });
+    try {
+      return await promptMemsourceVenv(rl);
+    } finally {
+      rl.close();
+    }
+  }
+  throw new Error(
+    "Memsource virtual environment path is required. Provide it via --memsource-venv option, or run in an interactive terminal to be prompted."
+  );
+}
+async function checkVirtualEnvironment(memsourceVenv) {
+  const expandedVenvPath = memsourceVenv.replaceAll(
+    /\$\{HOME\}/g,
+    os__default.default.homedir()
+  );
+  if (!await fs__default.default.pathExists(expandedVenvPath)) {
+    console.log(
+      chalk__default.default.yellow(
+        `
+\u26A0\uFE0F  Warning: Virtual environment not found at ${expandedVenvPath}`
+      )
+    );
+    console.log(
+      chalk__default.default.gray(
+        "   Please update the path in ~/.memsourcerc if your venv is located elsewhere."
+      )
+    );
+    console.log(
+      chalk__default.default.gray(
+        '   You can edit ~/.memsourcerc and update the "source" line with the correct path.'
+      )
+    );
+  }
+}
+async function setupMemsourceCommand(opts) {
+  console.log(
+    chalk__default.default.blue("\u{1F527} Setting up .memsourcerc file for Memsource CLI...")
+  );
+  const {
+    memsourceVenv,
+    memsourceUrl = "https://cloud.memsource.com/web",
+    username,
+    password
+  } = opts;
+  try {
+    const isInteractive = isInteractiveTerminal();
+    const noInput = opts.noInput === true;
+    const finalMemsourceVenv = await getMemsourceVenv(
+      memsourceVenv,
+      isInteractive,
+      noInput
+    );
+    const { username: finalUsername, password: finalPassword } = await getCredentials(isInteractive, noInput, username, password);
+    const memsourceRcContent = generateMemsourceRcContent(
+      finalMemsourceVenv,
+      memsourceUrl,
+      finalUsername,
+      finalPassword
+    );
+    const memsourceRcPath = path__default.default.join(os__default.default.homedir(), ".memsourcerc");
+    await fs__default.default.writeFile(memsourceRcPath, memsourceRcContent, { mode: 384 });
+    displaySetupInstructions(memsourceRcPath);
+    await checkVirtualEnvironment(finalMemsourceVenv);
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error setting up .memsourcerc:"), error);
+    throw error;
+  }
+}
+
+exports.setupMemsourceCommand = setupMemsourceCommand;
+//# sourceMappingURL=setupMemsource.cjs.js.map

package/dist/commands/status.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var chalk = require('chalk');
+var analyzeStatus = require('../lib/i18n/analyzeStatus.cjs.js');
+var formatReport = require('../lib/i18n/formatReport.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+async function statusCommand(opts) {
+  console.log(chalk__default.default.blue("\u{1F4CA} Analyzing translation status..."));
+  const {
+    sourceDir = "src",
+    i18nDir = "i18n",
+    localesDir = "src/locales",
+    format = "table",
+    includeStats = true
+  } = opts;
+  try {
+    const status = await analyzeStatus.analyzeTranslationStatus({
+      sourceDir,
+      i18nDir,
+      localesDir
+    });
+    const report = await formatReport.formatStatusReport(status, format, includeStats);
+    console.log(report);
+    console.log(chalk__default.default.green(`\u2705 Status analysis completed!`));
+    console.log(chalk__default.default.gray(`   Source files: ${status.sourceFiles.length}`));
+    console.log(chalk__default.default.gray(`   Translation keys: ${status.totalKeys}`));
+    console.log(chalk__default.default.gray(`   Languages: ${status.languages.length}`));
+    console.log(chalk__default.default.gray(`   Completion: ${status.overallCompletion}%`));
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error analyzing translation status:"), error);
+    throw error;
+  }
+}
+
+exports.statusCommand = statusCommand;
+//# sourceMappingURL=status.cjs.js.map

package/dist/commands/sync.cjs.js

@@ -0,0 +1,226 @@
+'use strict';
+
+var path = require('node:path');
+var chalk = require('chalk');
+var config = require('../lib/i18n/config.cjs.js');
+var exec = require('../lib/utils/exec.cjs.js');
+var generate = require('./generate.cjs.js');
+var upload = require('./upload.cjs.js');
+var download = require('./download.cjs.js');
+var deploy = require('./deploy.cjs.js');
+
+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);
+
+function hasTmsConfig(tmsUrl, tmsToken, projectId) {
+  return !!(tmsUrl && tmsToken && projectId);
+}
+async function executeStep(_stepName, action) {
+  await action();
+}
+function simulateStep(stepName) {
+  console.log(chalk__default.default.yellow(`\u{1F50D} Dry run: Would ${stepName}`));
+}
+async function stepGenerate(sourceDir, outputDir, sprint, dryRun) {
+  console.log(
+    chalk__default.default.blue("\n\u{1F4DD} Step 1: Generating translation reference files...")
+  );
+  if (dryRun) {
+    simulateStep("generate translation files");
+    return { step: "Generate" };
+  }
+  let generatedFile;
+  await executeStep("generate translation files", async () => {
+    if (!sprint) {
+      throw new Error(
+        "--sprint is required for generate command. Please provide --sprint option (e.g., --sprint s3285)"
+      );
+    }
+    await generate.generateCommand({
+      sourceDir,
+      outputDir,
+      sprint,
+      format: "json",
+      includePattern: "**/*.{ts,tsx,js,jsx}",
+      excludePattern: "**/node_modules/**",
+      extractKeys: true,
+      mergeExisting: false
+    });
+    const repoName = detectRepoName();
+    const normalizedSprint = sprint.startsWith("s") || sprint.startsWith("S") ? sprint.toLowerCase() : `s${sprint}`;
+    generatedFile = `${repoName.toLowerCase()}-${normalizedSprint}.json`;
+  });
+  return { step: "Generate", generatedFile };
+}
+function detectRepoName(repoPath) {
+  const targetPath = process.cwd();
+  try {
+    const gitRepoUrl = exec.safeExecSyncOrThrow(
+      "git",
+      ["config", "--get", "remote.origin.url"],
+      {
+        cwd: targetPath
+      }
+    );
+    if (gitRepoUrl) {
+      let repoName = gitRepoUrl.replace(/\.git$/, "");
+      const lastSlashIndex = repoName.lastIndexOf("/");
+      if (lastSlashIndex >= 0) {
+        repoName = repoName.substring(lastSlashIndex + 1);
+      }
+      if (repoName) {
+        return repoName;
+      }
+    }
+  } catch {
+  }
+  return path__default.default.basename(targetPath);
+}
+async function stepUpload(options, generatedFile) {
+  if (options.skipUpload) {
+    console.log(chalk__default.default.yellow("\u23ED\uFE0F  Skipping upload: --skip-upload specified"));
+    return null;
+  }
+  if (!hasTmsConfig(options.tmsUrl, options.tmsToken, options.projectId)) {
+    console.log(chalk__default.default.yellow("\u26A0\uFE0F  Skipping upload: Missing TMS configuration"));
+    return null;
+  }
+  const tmsUrl = options.tmsUrl;
+  const tmsToken = options.tmsToken;
+  const projectId = options.projectId;
+  console.log(chalk__default.default.blue("\n\u{1F4E4} Step 2: Uploading to TMS..."));
+  let sourceFile;
+  if (generatedFile) {
+    sourceFile = `${options.outputDir}/${generatedFile}`;
+  } else if (options.sprint) {
+    const repoName = detectRepoName();
+    const normalizedSprint = options.sprint.startsWith("s") || options.sprint.startsWith("S") ? options.sprint.toLowerCase() : `s${options.sprint}`;
+    sourceFile = `${options.outputDir}/${repoName.toLowerCase()}-${normalizedSprint}.json`;
+  } else {
+    throw new Error(
+      "Cannot determine source file for upload. Please provide --sprint option or ensure generate step completed successfully."
+    );
+  }
+  if (options.dryRun) {
+    simulateStep("upload to TMS");
+  } else {
+    await executeStep("upload to TMS", async () => {
+      await upload.uploadCommand({
+        tmsUrl,
+        tmsToken,
+        projectId,
+        sourceFile,
+        targetLanguages: options.languages,
+        dryRun: false
+      });
+    });
+  }
+  return "Upload";
+}
+async function stepDownload(options) {
+  if (options.skipDownload) {
+    console.log(
+      chalk__default.default.yellow("\u23ED\uFE0F  Skipping download: --skip-download specified")
+    );
+    return null;
+  }
+  if (!hasTmsConfig(options.tmsUrl, options.tmsToken, options.projectId)) {
+    console.log(
+      chalk__default.default.yellow("\u26A0\uFE0F  Skipping download: Missing TMS configuration")
+    );
+    return null;
+  }
+  const tmsUrl = options.tmsUrl;
+  const tmsToken = options.tmsToken;
+  const projectId = options.projectId;
+  console.log(chalk__default.default.blue("\n\u{1F4E5} Step 3: Downloading from TMS..."));
+  if (options.dryRun) {
+    simulateStep("download from TMS");
+  } else {
+    await executeStep("download from TMS", async () => {
+      await download.downloadCommand({
+        tmsUrl,
+        tmsToken,
+        projectId,
+        outputDir: options.outputDir,
+        languages: options.languages,
+        format: "json",
+        includeCompleted: true,
+        includeDraft: false
+      });
+    });
+  }
+  return "Download";
+}
+async function stepDeploy(options) {
+  if (options.skipDeploy) {
+    console.log(chalk__default.default.yellow("\u23ED\uFE0F  Skipping deploy: --skip-deploy specified"));
+    return null;
+  }
+  console.log(chalk__default.default.blue("\n\u{1F680} Step 4: Deploying to application..."));
+  if (options.dryRun) {
+    simulateStep("deploy to application");
+  } else {
+    await executeStep("deploy to application", async () => {
+      await deploy.deployCommand({
+        sourceDir: options.outputDir});
+    });
+  }
+  return "Deploy";
+}
+function displaySummary(steps, options) {
+  console.log(chalk__default.default.green("\n\u2705 i18n workflow completed successfully!"));
+  console.log(chalk__default.default.gray(`   Steps executed: ${steps.join(" \u2192 ")}`));
+  if (options.dryRun) {
+    console.log(
+      chalk__default.default.blue("\u{1F50D} This was a dry run - no actual changes were made")
+    );
+  } else {
+    console.log(chalk__default.default.gray(`   Source directory: ${options.sourceDir}`));
+    console.log(chalk__default.default.gray(`   Output directory: ${options.outputDir}`));
+    console.log(chalk__default.default.gray(`   Locales directory: ${options.localesDir}`));
+  }
+}
+async function syncCommand(opts) {
+  console.log(chalk__default.default.blue("\u{1F504} Running complete i18n workflow..."));
+  const config$1 = await config.loadI18nConfig();
+  const mergedOpts = await config.mergeConfigWithOptions(config$1, opts);
+  const options = {
+    sourceDir: String(mergedOpts.sourceDir || "src"),
+    outputDir: String(mergedOpts.outputDir || "i18n"),
+    localesDir: String(mergedOpts.localesDir || "src/locales"),
+    sprint: mergedOpts.sprint && typeof mergedOpts.sprint === "string" ? mergedOpts.sprint : void 0,
+    tmsUrl: mergedOpts.tmsUrl && typeof mergedOpts.tmsUrl === "string" ? mergedOpts.tmsUrl : void 0,
+    tmsToken: mergedOpts.tmsToken && typeof mergedOpts.tmsToken === "string" ? mergedOpts.tmsToken : void 0,
+    projectId: mergedOpts.projectId && typeof mergedOpts.projectId === "string" ? mergedOpts.projectId : void 0,
+    languages: mergedOpts.languages && typeof mergedOpts.languages === "string" ? mergedOpts.languages : void 0,
+    skipUpload: Boolean(mergedOpts.skipUpload ?? false),
+    skipDownload: Boolean(mergedOpts.skipDownload ?? false),
+    skipDeploy: Boolean(mergedOpts.skipDeploy ?? false),
+    dryRun: Boolean(mergedOpts.dryRun ?? false)
+  };
+  try {
+    const generateResult = await stepGenerate(
+      options.sourceDir,
+      options.outputDir,
+      options.sprint,
+      options.dryRun
+    );
+    const allSteps = [
+      generateResult.step,
+      await stepUpload(options, generateResult.generatedFile),
+      await stepDownload(options),
+      await stepDeploy(options)
+    ];
+    const steps = allSteps.filter((step) => Boolean(step));
+    displaySummary(steps, options);
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error in i18n workflow:"), error);
+    throw error;
+  }
+}
+
+exports.syncCommand = syncCommand;
+//# sourceMappingURL=sync.cjs.js.map