lingo.dev 0.78.17 → 0.79.1

package/build/cli.mjs

@@ -620,9 +620,9 @@ function makeGitlabInitializer(spinner) {
 
 // src/cli/cmd/init.ts
 import open2 from "open";
-var openUrl = (path14) => {
+var openUrl = (path15) => {
   const settings = getSettings(void 0);
-  open2(`${settings.auth.webUrl}${path14}`, { wait: false });
+  open2(`${settings.auth.webUrl}${path15}`, { wait: false });
 };
 var throwHelpError = (option, value) => {
   if (value === "help") {
@@ -962,8 +962,8 @@ var files_default = new Command4().command("files").description("Print out the l
           } else if (type.target) {
             result.push(...targetPaths);
           }
-          result.forEach((path14) => {
-            console.log(path14);
+          result.forEach((path15) => {
+            console.log(path15);
           });
         }
       }
@@ -1531,9 +1531,9 @@ function createHtmlLoader() {
         const bDepth = b.split("/").length;
         return aDepth - bDepth;
       });
-      paths.forEach((path14) => {
-        const value = data[path14];
-        const [nodePath, attribute] = path14.split("#");
+      paths.forEach((path15) => {
+        const value = data[path15];
+        const [nodePath, attribute] = path15.split("#");
         const [rootTag, ...indices] = nodePath.split("/");
         let parent = rootTag === "head" ? document.head : document.body;
         let current = parent;
@@ -2597,18 +2597,18 @@ function createRawDatoValue(parsedDatoValue, originalRawDatoValue, isClean = fal
 }
 function serializeStructuredText(rawStructuredText) {
   return serializeStructuredTextNode(rawStructuredText);
-  function serializeStructuredTextNode(node, path14 = [], acc = {}) {
+  function serializeStructuredTextNode(node, path15 = [], acc = {}) {
     if ("document" in node) {
-      return serializeStructuredTextNode(node.document, [...path14, "document"], acc);
+      return serializeStructuredTextNode(node.document, [...path15, "document"], acc);
     }
     if (!_15.isNil(node.value)) {
-      acc[[...path14, "value"].join(".")] = node.value;
+      acc[[...path15, "value"].join(".")] = node.value;
     } else if (_15.get(node, "type") === "block") {
-      acc[[...path14, "item"].join(".")] = serializeBlock(node.item);
+      acc[[...path15, "item"].join(".")] = serializeBlock(node.item);
     }
     if (node.children) {
       for (let i = 0; i < node.children.length; i++) {
-        serializeStructuredTextNode(node.children[i], [...path14, i.toString()], acc);
+        serializeStructuredTextNode(node.children[i], [...path15, i.toString()], acc);
       }
     }
     return acc;
@@ -2667,8 +2667,8 @@ function deserializeBlockList(parsedBlockList, originalRawBlockList, isClean = f
 }
 function deserializeStructuredText(parsedStructuredText, originalRawStructuredText) {
   const result = _15.cloneDeep(originalRawStructuredText);
-  for (const [path14, value] of _15.entries(parsedStructuredText)) {
-    const realPath = _15.chain(path14.split(".")).flatMap((s) => !_15.isNaN(_15.toNumber(s)) ? ["children", s] : s).value();
+  for (const [path15, value] of _15.entries(parsedStructuredText)) {
+    const realPath = _15.chain(path15.split(".")).flatMap((s) => !_15.isNaN(_15.toNumber(s)) ? ["children", s] : s).value();
     const deserializedValue = createRawDatoValue(value, _15.get(originalRawStructuredText, realPath), true);
     _15.set(result, realPath, deserializedValue);
   }
@@ -3305,7 +3305,16 @@ function _tryParseJSON(line) {
 }
 
 // src/cli/cmd/i18n.ts
-var i18n_default = new Command6().command("i18n").description("Run Localization engine").helpOption("-h, --help", "Show help").option("--locale <locale>", "Locale to process", (val, prev) => prev ? [...prev, val] : [val]).option("--bucket <bucket>", "Bucket to process", (val, prev) => prev ? [...prev, val] : [val]).option("--key <key>", "Key to process. Process only a specific translation key, useful for debugging or updating a single entry").option("--frozen", `Run in read-only mode - fails if any translations need updating, useful for CI/CD pipelines to detect missing translations`).option("--force", "Ignore lockfile and process all keys, useful for full re-translation").option("--verbose", "Show detailed output including intermediate processing data and API communication details").option("--interactive", "Enable interactive mode for reviewing and editing translations before they are applied").option("--api-key <api-key>", "Explicitly set the API key to use, override the default API key from settings").option("--debug", "Pause execution at start for debugging purposes, waits for user confirmation before proceeding").option("--strict", "Stop processing on first error instead of continuing with other locales/buckets").action(async function(options) {
+var i18n_default = new Command6().command("i18n").description("Run Localization engine").helpOption("-h, --help", "Show help").option("--locale <locale>", "Locale to process", (val, prev) => prev ? [...prev, val] : [val]).option("--bucket <bucket>", "Bucket to process", (val, prev) => prev ? [...prev, val] : [val]).option(
+  "--key <key>",
+  "Key to process. Process only a specific translation key, useful for debugging or updating a single entry"
+).option(
+  "--file [files...]",
+  "File to process. Process only a specific path, may contain asterisk * to match multiple files. Useful if you have a lot of files and want to focus on a specific one. Specify more files separated by commas or spaces."
+).option(
+  "--frozen",
+  `Run in read-only mode - fails if any translations need updating, useful for CI/CD pipelines to detect missing translations`
+).option("--force", "Ignore lockfile and process all keys, useful for full re-translation").option("--verbose", "Show detailed output including intermediate processing data and API communication details").option("--interactive", "Enable interactive mode for reviewing and editing translations before they are applied").option("--api-key <api-key>", "Explicitly set the API key to use, override the default API key from settings").option("--debug", "Pause execution at start for debugging purposes, waits for user confirmation before proceeding").option("--strict", "Stop processing on first error instead of continuing with other locales/buckets").action(async function(options) {
   updateGitignore();
   const ora = Ora5();
   const flags = parseFlags(options);
@@ -3335,6 +3344,26 @@ var i18n_default = new Command6().command("i18n").description("Run Localization
       buckets = buckets.filter((bucket) => flags.bucket.includes(bucket.type));
     }
     ora.succeed("Buckets retrieved");
+    if (flags.file?.length) {
+      buckets = buckets.map((bucket) => {
+        const config = bucket.config.filter(
+          (config2) => flags.file.find((file) => config2.pathPattern?.match(file))
+        );
+        return { ...bucket, config };
+      }).filter((bucket) => bucket.config.length > 0);
+      if (buckets.length === 0) {
+        ora.fail("No buckets found. All buckets were filtered out by --file option.");
+        process.exit(1);
+      } else {
+        ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
+        buckets.map((bucket) => {
+          ora.info(`  ${bucket.type}:`);
+          bucket.config.forEach((config) => {
+            ora.info(`    - ${config.pathPattern}`);
+          });
+        });
+      }
+    }
     const targetLocales = flags.locale?.length ? flags.locale : i18nConfig.locale.targets;
     const lockfileHelper = createLockfileHelper();
     ora.start("Ensuring i18n.lock exists...");
@@ -3630,6 +3659,7 @@ function parseFlags(options) {
     verbose: Z4.boolean().optional(),
     strict: Z4.boolean().optional(),
     key: Z4.string().optional(),
+    file: Z4.array(Z4.string()).optional(),
     interactive: Z4.boolean().default(false),
     debug: Z4.boolean().default(false)
   }).parse(options);
@@ -3953,10 +3983,637 @@ var mcp_default = new Command9().command("mcp").description("Use Lingo.dev model
   console.log("Lingo.dev MCP Server running on stdio");
 });
 
+// src/cli/cmd/ci.ts
+import { Command as Command10 } from "interactive-commander";
+
+// ../../action/src/main.ts
+import createOra from "ora";
+
+// ../../action/src/flows/pull-request.ts
+import { execSync as execSync3 } from "child_process";
+
+// ../../action/src/flows/in-branch.ts
+import { execSync as execSync2 } from "child_process";
+import path14 from "path";
+
+// ../../action/src/flows/_base.ts
+var IntegrationFlow = class {
+  constructor(ora, platformKit) {
+    this.ora = ora;
+    this.platformKit = platformKit;
+  }
+  i18nBranchName;
+};
+var gitConfig = {
+  userName: "Lingo.dev",
+  userEmail: "support@lingo.dev"
+};
+
+// ../../action/src/flows/in-branch.ts
+var InBranchFlow = class extends IntegrationFlow {
+  async preRun() {
+    this.ora.start("Configuring git");
+    const canContinue = this.configureGit();
+    this.ora.succeed("Git configured");
+    return canContinue;
+  }
+  async run(forcePush = false) {
+    this.ora.start("Running Lingo.dev");
+    await this.runLingoDotDev();
+    this.ora.succeed("Done running Lingo.dev");
+    execSync2(`rm -f i18n.cache`, { stdio: "inherit" });
+    this.ora.start("Checking for changes");
+    const hasChanges = this.checkCommitableChanges();
+    this.ora.succeed(hasChanges ? "Changes detected" : "No changes detected");
+    if (hasChanges) {
+      this.ora.start("Committing changes");
+      execSync2(`git add .`, { stdio: "inherit" });
+      execSync2(`git status --porcelain`, { stdio: "inherit" });
+      execSync2(`git commit -m "${this.platformKit.config.commitMessage}"`, {
+        stdio: "inherit"
+      });
+      this.ora.succeed("Changes committed");
+      this.ora.start("Pushing changes to remote");
+      const currentBranch = this.i18nBranchName ?? this.platformKit.platformConfig.baseBranchName;
+      execSync2(`git push origin ${currentBranch} ${forcePush ? "--force" : ""}`, {
+        stdio: "inherit"
+      });
+      this.ora.succeed("Changes pushed to remote");
+    }
+    return hasChanges;
+  }
+  checkCommitableChanges() {
+    return execSync2('git status --porcelain || echo "has_changes"', {
+      encoding: "utf8"
+    }).length > 0;
+  }
+  async runLingoDotDev() {
+    execSync2(`npx lingo.dev@latest i18n --api-key ${this.platformKit.config.replexicaApiKey}`, { stdio: "inherit" });
+  }
+  configureGit() {
+    const { processOwnCommits } = this.platformKit.config;
+    const { baseBranchName } = this.platformKit.platformConfig;
+    this.ora.info(`Current working directory:`);
+    execSync2(`pwd`, { stdio: "inherit" });
+    execSync2(`ls -la`, { stdio: "inherit" });
+    execSync2(`git config --global safe.directory ${process.cwd()}`);
+    execSync2(`git config user.name "${gitConfig.userName}"`);
+    execSync2(`git config user.email "${gitConfig.userEmail}"`);
+    this.platformKit?.gitConfig();
+    execSync2(`git fetch origin ${baseBranchName}`, { stdio: "inherit" });
+    execSync2(`git checkout ${baseBranchName} --`, { stdio: "inherit" });
+    if (!processOwnCommits) {
+      const currentAuthor = `${gitConfig.userName} <${gitConfig.userEmail}>`;
+      const authorOfLastCommit = execSync2(`git log -1 --pretty=format:'%an <%ae>'`).toString();
+      if (authorOfLastCommit === currentAuthor) {
+        this.ora.warn(
+          `The last commit was already made by ${currentAuthor}, so this run will be skipped, as running again would have no effect. See docs: https://docs.lingo.dev/ci-action/overview`
+        );
+        return false;
+      }
+    }
+    const workingDir = path14.resolve(process.cwd(), this.platformKit.config.workingDir);
+    if (workingDir !== process.cwd()) {
+      this.ora.info(`Changing to working directory: ${this.platformKit.config.workingDir}`);
+      process.chdir(workingDir);
+    }
+    return true;
+  }
+};
+
+// ../../action/src/flows/pull-request.ts
+var PullRequestFlow = class extends InBranchFlow {
+  async preRun() {
+    const canContinue = await super.preRun?.();
+    if (!canContinue) {
+      return false;
+    }
+    this.ora.start("Calculating automated branch name");
+    this.i18nBranchName = this.calculatePrBranchName();
+    this.ora.succeed(`Automated branch name calculated: ${this.i18nBranchName}`);
+    this.ora.start("Checking if branch exists");
+    const branchExists = await this.checkBranchExistance(this.i18nBranchName);
+    this.ora.succeed(branchExists ? "Branch exists" : "Branch does not exist");
+    if (branchExists) {
+      this.ora.start(`Checking out branch ${this.i18nBranchName}`);
+      this.checkoutI18nBranch(this.i18nBranchName);
+      this.ora.succeed(`Checked out branch ${this.i18nBranchName}`);
+      this.ora.start(`Syncing with ${this.platformKit.platformConfig.baseBranchName}`);
+      this.syncI18nBranch();
+      this.ora.succeed(`Checked out and synced branch ${this.i18nBranchName}`);
+    } else {
+      this.ora.start(`Creating branch ${this.i18nBranchName}`);
+      this.createI18nBranch(this.i18nBranchName);
+      this.ora.succeed(`Created branch ${this.i18nBranchName}`);
+    }
+    return true;
+  }
+  async run() {
+    return super.run(true);
+  }
+  async postRun() {
+    if (!this.i18nBranchName) {
+      throw new Error("i18nBranchName is not set. Did you forget to call preRun?");
+    }
+    this.ora.start("Checking if PR already exists");
+    const pullRequestNumber = await this.ensureFreshPr(this.i18nBranchName);
+    this.ora.succeed(`Pull request ready: ${this.platformKit.buildPullRequestUrl(pullRequestNumber)}`);
+  }
+  calculatePrBranchName() {
+    return `lingo.dev/${this.platformKit.platformConfig.baseBranchName}`;
+  }
+  async checkBranchExistance(prBranchName) {
+    return this.platformKit.branchExists({
+      branch: prBranchName
+    });
+  }
+  async ensureFreshPr(i18nBranchName) {
+    this.ora.start(
+      `Checking for existing PR with head ${i18nBranchName} and base ${this.platformKit.platformConfig.baseBranchName}`
+    );
+    const existingPrNumber = await this.platformKit.getOpenPullRequestNumber({
+      branch: i18nBranchName
+    });
+    this.ora.succeed(existingPrNumber ? "PR found" : "No PR found");
+    if (existingPrNumber) {
+      this.ora.start(`Closing existing PR ${existingPrNumber}`);
+      await this.platformKit.closePullRequest({
+        pullRequestNumber: existingPrNumber
+      });
+      this.ora.succeed(`Closed existing PR ${existingPrNumber}`);
+    }
+    this.ora.start(`Creating new PR`);
+    const newPrNumber = await this.platformKit.createPullRequest({
+      head: i18nBranchName,
+      title: this.platformKit.config.pullRequestTitle,
+      body: this.getPrBodyContent()
+    });
+    this.ora.succeed(`Created new PR ${newPrNumber}`);
+    if (existingPrNumber) {
+      this.ora.start(`Posting comment about outdated PR ${existingPrNumber}`);
+      await this.platformKit.commentOnPullRequest({
+        pullRequestNumber: existingPrNumber,
+        body: `This PR is now outdated. A new version has been created at ${this.platformKit.buildPullRequestUrl(
+          newPrNumber
+        )}`
+      });
+      this.ora.succeed(`Posted comment about outdated PR ${existingPrNumber}`);
+    }
+    return newPrNumber;
+  }
+  checkoutI18nBranch(i18nBranchName) {
+    execSync3(`git fetch origin ${i18nBranchName}`, { stdio: "inherit" });
+    execSync3(`git checkout -b ${i18nBranchName}`, {
+      stdio: "inherit"
+    });
+  }
+  createI18nBranch(i18nBranchName) {
+    try {
+      execSync3(`git fetch origin ${this.platformKit.platformConfig.baseBranchName}`, { stdio: "inherit" });
+      execSync3(`git checkout -b ${i18nBranchName} origin/${this.platformKit.platformConfig.baseBranchName}`, {
+        stdio: "inherit"
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+      this.ora.fail(`Failed to create branch: ${errorMessage}`);
+      this.ora.info(`
+      Troubleshooting tips:
+      1. Make sure you have permission to create branches
+      2. Check if the branch already exists locally (try 'git branch -a')
+      3. Verify connectivity to remote repository
+    `);
+      throw new Error(`Branch creation failed: ${errorMessage}`);
+    }
+  }
+  syncI18nBranch() {
+    if (!this.i18nBranchName) {
+      throw new Error("i18nBranchName is not set");
+    }
+    this.ora.start(`Fetching latest changes from ${this.platformKit.platformConfig.baseBranchName}`);
+    execSync3(`git fetch origin ${this.platformKit.platformConfig.baseBranchName}`, { stdio: "inherit" });
+    this.ora.succeed(`Fetched latest changes from ${this.platformKit.platformConfig.baseBranchName}`);
+    try {
+      this.ora.start("Attempting to rebase branch");
+      execSync3(`git rebase origin/${this.platformKit.platformConfig.baseBranchName}`, { stdio: "inherit" });
+      this.ora.succeed("Successfully rebased branch");
+    } catch (error) {
+      this.ora.warn("Rebase failed, falling back to alternative sync method");
+      this.ora.start("Aborting failed rebase");
+      execSync3("git rebase --abort", { stdio: "inherit" });
+      this.ora.succeed("Aborted failed rebase");
+      this.ora.start(`Resetting to ${this.platformKit.platformConfig.baseBranchName}`);
+      execSync3(`git reset --hard origin/${this.platformKit.platformConfig.baseBranchName}`, { stdio: "inherit" });
+      this.ora.succeed(`Reset to ${this.platformKit.platformConfig.baseBranchName}`);
+      this.ora.start("Restoring target files");
+      const targetFiles = ["i18n.lock"];
+      const targetFileNames = execSync3(
+        `npx lingo.dev@latest show files --target ${this.platformKit.platformConfig.baseBranchName}`,
+        { encoding: "utf8" }
+      ).split("\n").filter(Boolean);
+      targetFiles.push(...targetFileNames);
+      execSync3(`git fetch origin ${this.i18nBranchName}`, { stdio: "inherit" });
+      for (const file of targetFiles) {
+        try {
+          execSync3(`git checkout FETCH_HEAD -- ${file}`, { stdio: "inherit" });
+        } catch (error2) {
+          this.ora.warn(`Skipping non-existent file: ${file}`);
+          continue;
+        }
+      }
+      this.ora.succeed("Restored target files");
+    }
+    this.ora.start("Checking for changes to commit");
+    const hasChanges = this.checkCommitableChanges();
+    if (hasChanges) {
+      execSync3("git add .", { stdio: "inherit" });
+      execSync3(`git commit -m "chore: sync with ${this.platformKit.platformConfig.baseBranchName}"`, {
+        stdio: "inherit"
+      });
+      this.ora.succeed("Committed additional changes");
+    } else {
+      this.ora.succeed("No changes to commit");
+    }
+  }
+  getPrBodyContent() {
+    return `
+Hey team,
+
+[**Lingo.dev**](https://lingo.dev) here with fresh translations!
+
+### In this update
+
+- Added missing translations
+- Performed brand voice, context and glossary checks
+- Enhanced translations using Lingo.dev Localization Engine
+
+### Next Steps
+
+- [ ] Review the changes
+- [ ] Merge when ready
+    `.trim();
+  }
+};
+
+// ../../action/src/platforms/bitbucket.ts
+import { execSync as execSync4 } from "child_process";
+import bbLib from "bitbucket";
+import Z8 from "zod";
+
+// ../../action/src/platforms/_base.ts
+import Z7 from "zod";
+var defaultMessage = "feat: update translations via @lingodotdev";
+var PlatformKit = class {
+  gitConfig() {
+  }
+  get config() {
+    const env = Z7.object({
+      LINGODOTDEV_API_KEY: Z7.string(),
+      LINGODOTDEV_PULL_REQUEST: Z7.preprocess((val) => val === "true" || val === true, Z7.boolean()),
+      LINGODOTDEV_COMMIT_MESSAGE: Z7.string().optional(),
+      LINGODOTDEV_PULL_REQUEST_TITLE: Z7.string().optional(),
+      LINGODOTDEV_WORKING_DIRECTORY: Z7.string().optional(),
+      LINGODOTDEV_PROCESS_OWN_COMMITS: Z7.preprocess((val) => val === "true" || val === true, Z7.boolean()).optional()
+    }).parse(process.env);
+    return {
+      replexicaApiKey: env.LINGODOTDEV_API_KEY,
+      isPullRequestMode: env.LINGODOTDEV_PULL_REQUEST,
+      commitMessage: env.LINGODOTDEV_COMMIT_MESSAGE || defaultMessage,
+      pullRequestTitle: env.LINGODOTDEV_PULL_REQUEST_TITLE || defaultMessage,
+      workingDir: env.LINGODOTDEV_WORKING_DIRECTORY || ".",
+      processOwnCommits: env.LINGODOTDEV_PROCESS_OWN_COMMITS || false
+    };
+  }
+};
+
+// ../../action/src/platforms/bitbucket.ts
+var { Bitbucket } = bbLib;
+var BitbucketPlatformKit = class extends PlatformKit {
+  _bb;
+  get bb() {
+    if (!this._bb) {
+      this._bb = new Bitbucket({
+        auth: { token: this.platformConfig.bbToken || "" }
+      });
+    }
+    return this._bb;
+  }
+  async branchExists({ branch }) {
+    return await this.bb.repositories.getBranch({
+      workspace: this.platformConfig.repositoryOwner,
+      repo_slug: this.platformConfig.repositoryName,
+      name: branch
+    }).then((r) => r.data).then((v) => !!v).catch((r) => r.status === 404 ? false : Promise.reject(r));
+  }
+  async getOpenPullRequestNumber({ branch }) {
+    return await this.bb.repositories.listPullRequests({
+      workspace: this.platformConfig.repositoryOwner,
+      repo_slug: this.platformConfig.repositoryName,
+      state: "OPEN"
+    }).then(({ data: { values } }) => {
+      return values?.find(
+        ({ source, destination }) => source?.branch?.name === branch && destination?.branch?.name === this.platformConfig.baseBranchName
+      );
+    }).then((pr) => pr?.id);
+  }
+  async closePullRequest({ pullRequestNumber }) {
+    await this.bb.repositories.declinePullRequest({
+      workspace: this.platformConfig.repositoryOwner,
+      repo_slug: this.platformConfig.repositoryName,
+      pull_request_id: pullRequestNumber
+    });
+  }
+  async createPullRequest({ title, body, head }) {
+    return await this.bb.repositories.createPullRequest({
+      workspace: this.platformConfig.repositoryOwner,
+      repo_slug: this.platformConfig.repositoryName,
+      _body: {
+        title,
+        description: body,
+        source: { branch: { name: head } },
+        destination: { branch: { name: this.platformConfig.baseBranchName } }
+      }
+    }).then(({ data }) => data.id ?? 0);
+  }
+  async commentOnPullRequest({ pullRequestNumber, body }) {
+    await this.bb.repositories.createPullRequestComment({
+      workspace: this.platformConfig.repositoryOwner,
+      repo_slug: this.platformConfig.repositoryName,
+      pull_request_id: pullRequestNumber,
+      _body: {
+        content: {
+          raw: body
+        }
+      }
+    });
+  }
+  async gitConfig() {
+    execSync4("git config --unset http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy", {
+      stdio: "inherit"
+    });
+    execSync4("git config http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy http://host.docker.internal:29418/", {
+      stdio: "inherit"
+    });
+  }
+  get platformConfig() {
+    const env = Z8.object({
+      BITBUCKET_BRANCH: Z8.string(),
+      BITBUCKET_REPO_FULL_NAME: Z8.string(),
+      BB_TOKEN: Z8.string().optional()
+    }).parse(process.env);
+    const [repositoryOwner, repositoryName] = env.BITBUCKET_REPO_FULL_NAME.split("/");
+    return {
+      baseBranchName: env.BITBUCKET_BRANCH,
+      repositoryOwner,
+      repositoryName,
+      bbToken: env.BB_TOKEN
+    };
+  }
+  buildPullRequestUrl(pullRequestNumber) {
+    const { repositoryOwner, repositoryName } = this.platformConfig;
+    return `https://bitbucket.org/${repositoryOwner}/${repositoryName}/pull-requests/${pullRequestNumber}`;
+  }
+};
+
+// ../../action/src/platforms/github.ts
+import { Octokit } from "octokit";
+import Z9 from "zod";
+import { execSync as execSync5 } from "child_process";
+var GitHubPlatformKit = class extends PlatformKit {
+  _octokit;
+  get octokit() {
+    if (!this._octokit) {
+      this._octokit = new Octokit({ auth: this.platformConfig.ghToken });
+    }
+    return this._octokit;
+  }
+  async branchExists({ branch }) {
+    return await this.octokit.rest.repos.getBranch({
+      branch,
+      owner: this.platformConfig.repositoryOwner,
+      repo: this.platformConfig.repositoryName
+    }).then((r) => r.data).then((v) => !!v).catch((r) => r.status === 404 ? false : Promise.reject(r));
+  }
+  async getOpenPullRequestNumber({ branch }) {
+    return await this.octokit.rest.pulls.list({
+      head: `${this.platformConfig.repositoryOwner}:${branch}`,
+      owner: this.platformConfig.repositoryOwner,
+      repo: this.platformConfig.repositoryName,
+      base: this.platformConfig.baseBranchName,
+      state: "open"
+    }).then(({ data }) => data[0]).then((pr) => pr?.number);
+  }
+  async closePullRequest({ pullRequestNumber }) {
+    await this.octokit.rest.pulls.update({
+      pull_number: pullRequestNumber,
+      owner: this.platformConfig.repositoryOwner,
+      repo: this.platformConfig.repositoryName,
+      state: "closed"
+    });
+  }
+  async createPullRequest({ head, title, body }) {
+    return await this.octokit.rest.pulls.create({
+      head,
+      title,
+      body,
+      owner: this.platformConfig.repositoryOwner,
+      repo: this.platformConfig.repositoryName,
+      base: this.platformConfig.baseBranchName
+    }).then(({ data }) => data.number);
+  }
+  async commentOnPullRequest({ pullRequestNumber, body }) {
+    await this.octokit.rest.issues.createComment({
+      issue_number: pullRequestNumber,
+      body,
+      owner: this.platformConfig.repositoryOwner,
+      repo: this.platformConfig.repositoryName
+    });
+  }
+  async gitConfig() {
+    const { ghToken, repositoryOwner, repositoryName } = this.platformConfig;
+    const { processOwnCommits } = this.config;
+    if (ghToken && processOwnCommits) {
+      console.log("Using provided GH_TOKEN. This will trigger your CI/CD pipeline to run again.");
+      const url = `https://${ghToken}@github.com/${repositoryOwner}/${repositoryName}.git`;
+      execSync5(`git remote set-url origin ${url}`, {
+        stdio: "inherit"
+      });
+    }
+  }
+  get platformConfig() {
+    const env = Z9.object({
+      GITHUB_REPOSITORY: Z9.string(),
+      GITHUB_REPOSITORY_OWNER: Z9.string(),
+      GITHUB_REF_NAME: Z9.string(),
+      GITHUB_HEAD_REF: Z9.string(),
+      GH_TOKEN: Z9.string().optional()
+    }).parse(process.env);
+    const baseBranchName = !env.GITHUB_REF_NAME.endsWith("/merge") ? env.GITHUB_REF_NAME : env.GITHUB_HEAD_REF;
+    return {
+      ghToken: env.GH_TOKEN,
+      baseBranchName,
+      repositoryOwner: env.GITHUB_REPOSITORY_OWNER,
+      repositoryName: env.GITHUB_REPOSITORY.split("/")[1]
+    };
+  }
+  buildPullRequestUrl(pullRequestNumber) {
+    const { repositoryOwner, repositoryName } = this.platformConfig;
+    return `https://github.com/${repositoryOwner}/${repositoryName}/pull/${pullRequestNumber}`;
+  }
+};
+
+// ../../action/src/platforms/gitlab.ts
+import { Gitlab } from "@gitbeaker/rest";
+import Z10 from "zod";
+import { execSync as execSync6 } from "child_process";
+var gl = new Gitlab({ token: "" });
+var GitlabPlatformKit = class extends PlatformKit {
+  _gitlab;
+  constructor() {
+    super();
+    process.chdir(this.platformConfig.projectDir);
+  }
+  get gitlab() {
+    if (!this._gitlab) {
+      this._gitlab = new Gitlab({
+        token: this.platformConfig.glToken || ""
+      });
+    }
+    return this._gitlab;
+  }
+  get platformConfig() {
+    const env = Z10.object({
+      GL_TOKEN: Z10.string().optional(),
+      CI_COMMIT_BRANCH: Z10.string(),
+      CI_MERGE_REQUEST_SOURCE_BRANCH_NAME: Z10.string().optional(),
+      CI_PROJECT_NAMESPACE: Z10.string(),
+      CI_PROJECT_NAME: Z10.string(),
+      CI_PROJECT_ID: Z10.string(),
+      CI_PROJECT_DIR: Z10.string(),
+      CI_REPOSITORY_URL: Z10.string()
+    }).parse(process.env);
+    const config = {
+      glToken: env.GL_TOKEN,
+      baseBranchName: env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME ?? env.CI_COMMIT_BRANCH,
+      repositoryOwner: env.CI_PROJECT_NAMESPACE,
+      repositoryName: env.CI_PROJECT_NAME,
+      gitlabProjectId: env.CI_PROJECT_ID,
+      projectDir: env.CI_PROJECT_DIR,
+      reporitoryUrl: env.CI_REPOSITORY_URL
+    };
+    return config;
+  }
+  async branchExists({ branch }) {
+    try {
+      await this.gitlab.Branches.show(this.platformConfig.gitlabProjectId, branch);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getOpenPullRequestNumber({ branch }) {
+    const mergeRequests = await this.gitlab.MergeRequests.all({
+      projectId: this.platformConfig.gitlabProjectId,
+      sourceBranch: branch,
+      state: "opened"
+    });
+    return mergeRequests[0]?.iid;
+  }
+  async closePullRequest({ pullRequestNumber }) {
+    await this.gitlab.MergeRequests.edit(this.platformConfig.gitlabProjectId, pullRequestNumber, {
+      stateEvent: "close"
+    });
+  }
+  async createPullRequest({ head, title, body }) {
+    const mr = await this.gitlab.MergeRequests.create(
+      this.platformConfig.gitlabProjectId,
+      head,
+      this.platformConfig.baseBranchName,
+      title,
+      {
+        description: body
+      }
+    );
+    return mr.iid;
+  }
+  async commentOnPullRequest({ pullRequestNumber, body }) {
+    await this.gitlab.MergeRequestNotes.create(this.platformConfig.gitlabProjectId, pullRequestNumber, body);
+  }
+  gitConfig() {
+    const url = `https://oauth2:${this.platformConfig.glToken}@gitlab.com/${this.platformConfig.repositoryOwner}/${this.platformConfig.repositoryName}.git`;
+    execSync6(`git remote set-url origin ${url}`, {
+      stdio: "inherit"
+    });
+  }
+  buildPullRequestUrl(pullRequestNumber) {
+    return `https://gitlab.com/${this.platformConfig.repositoryOwner}/${this.platformConfig.repositoryName}/-/merge_requests/${pullRequestNumber}`;
+  }
+};
+
+// ../../action/src/platforms/index.ts
+var getPlatformKit = () => {
+  if (process.env.BITBUCKET_PIPELINE_UUID) {
+    return new BitbucketPlatformKit();
+  }
+  if (process.env.GITHUB_ACTION) {
+    return new GitHubPlatformKit();
+  }
+  if (process.env.GITLAB_CI) {
+    return new GitlabPlatformKit();
+  }
+  throw new Error("This platform is not supported");
+};
+
+// ../../action/src/main.ts
+async function main() {
+  const ora = createOra();
+  const platformKit = getPlatformKit();
+  const { isPullRequestMode } = platformKit.config;
+  ora.info(`Pull request mode: ${isPullRequestMode ? "on" : "off"}`);
+  const flow = isPullRequestMode ? new PullRequestFlow(ora, platformKit) : new InBranchFlow(ora, platformKit);
+  const canRun = await flow.preRun?.();
+  if (canRun === false) {
+    return;
+  }
+  const hasChanges = await flow.run();
+  if (!hasChanges) {
+    return;
+  }
+  await flow.postRun?.();
+}
+
+// src/cli/cmd/ci.ts
+var ci_default = new Command10().command("ci").description("Run Lingo.dev CI/CD action").helpOption("-h, --help", "Show help").option("--pull-request", "Create a pull request with the changes", false).option("--commit-message <message>", "Commit message").option("--pull-request-title <title>", "Pull request title").option("--working-directory <dir>", "Working directory").option("--process-own-commits", "Process commits made by this action", false).action(async (options, program) => {
+  const apiKey = program.args[0];
+  const settings = getSettings(apiKey);
+  if (!settings.auth.apiKey) {
+    console.error("No API key provided");
+    return;
+  }
+  const authenticator = createAuthenticator({
+    apiUrl: settings.auth.apiUrl,
+    apiKey: settings.auth.apiKey
+  });
+  const auth = await authenticator.whoami();
+  if (!auth) {
+    console.error("Not authenticated");
+    return;
+  }
+  const env = {
+    LINGODOTDEV_API_KEY: settings.auth.apiKey,
+    LINGODOTDEV_PULL_REQUEST: options.pullRequest?.toString() || "false",
+    ...options.commitMessage && { LINGODOTDEV_COMMIT_MESSAGE: options.commitMessage },
+    ...options.pullRequestTitle && { LINGODOTDEV_PULL_REQUEST_TITLE: options.pullRequestTitle },
+    ...options.workingDirectory && { LINGODOTDEV_WORKING_DIRECTORY: options.workingDirectory },
+    ...options.processOwnCommits && { LINGODOTDEV_PROCESS_OWN_COMMITS: options.processOwnCommits.toString() }
+  };
+  process.env = { ...process.env, ...env };
+  main();
+});
+
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.78.17",
+  version: "0.79.1",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -4014,11 +4671,13 @@ var package_default = {
   license: "Apache-2.0",
   dependencies: {
     "@datocms/cma-client-node": "^3.4.0",
+    "@gitbeaker/rest": "^39.34.3",
     "@inquirer/prompts": "^7.2.3",
     "@lingo.dev/_sdk": "workspace:*",
     "@lingo.dev/_spec": "workspace:*",
     "@modelcontextprotocol/sdk": "^1.5.0",
     "@paralleldrive/cuid2": "^2.2.2",
+    bitbucket: "^2.12.0",
     chalk: "^5.4.1",
     cors: "^2.8.5",
     "csv-parse": "^5.6.0",
@@ -4048,6 +4707,7 @@ var package_default = {
     marked: "^15.0.6",
     "node-webvtt": "^1.9.4",
     "object-hash": "^3.0.0",
+    octokit: "^4.0.2",
     open: "^10.1.0",
     ora: "^8.1.1",
     "p-limit": "^6.2.0",
@@ -4107,7 +4767,7 @@ ${vice(
 
 Website: https://lingo.dev
 `
-).version(`v${package_default.version}`, "-v, --version", "Show version").addCommand(init_default).interactive("-y, --no-interactive", "Disable interactive mode").addCommand(i18n_default).addCommand(auth_default).addCommand(show_default).addCommand(lockfile_default).addCommand(cleanup_default).addCommand(mcp_default).exitOverride((err) => {
+).version(`v${package_default.version}`, "-v, --version", "Show version").addCommand(init_default).interactive("-y, --no-interactive", "Disable interactive mode").addCommand(i18n_default).addCommand(auth_default).addCommand(show_default).addCommand(lockfile_default).addCommand(cleanup_default).addCommand(mcp_default).addCommand(ci_default).exitOverride((err) => {
   if (err.code === "commander.helpDisplayed" || err.code === "commander.version" || err.code === "commander.help") {
     process.exit(0);
   }