lingo.dev 0.78.16 → 0.79.0

package/build/cli.cjs

@@ -620,9 +620,9 @@ function makeGitlabInitializer(spinner) {
 
 // src/cli/cmd/init.ts
 
-var openUrl = (path14) => {
+var openUrl = (path15) => {
   const settings = getSettings(void 0);
-  _open2.default.call(void 0, `${settings.auth.webUrl}${path14}`, { wait: false });
+  _open2.default.call(void 0, `${settings.auth.webUrl}${path15}`, { wait: false });
 };
 var throwHelpError = (option, value) => {
   if (value === "help") {
@@ -962,8 +962,8 @@ var files_default = new (0, _interactivecommander.Command)().command("files").de
           } 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 (!_lodash2.default.isNil(node.value)) {
-      acc[[...path14, "value"].join(".")] = node.value;
+      acc[[...path15, "value"].join(".")] = node.value;
     } else if (_lodash2.default.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 = _lodash2.default.cloneDeep(originalRawStructuredText);
-  for (const [path14, value] of _lodash2.default.entries(parsedStructuredText)) {
-    const realPath = _lodash2.default.chain(path14.split(".")).flatMap((s) => !_lodash2.default.isNaN(_lodash2.default.toNumber(s)) ? ["children", s] : s).value();
+  for (const [path15, value] of _lodash2.default.entries(parsedStructuredText)) {
+    const realPath = _lodash2.default.chain(path15.split(".")).flatMap((s) => !_lodash2.default.isNaN(_lodash2.default.toNumber(s)) ? ["children", s] : s).value();
     const deserializedValue = createRawDatoValue(value, _lodash2.default.get(originalRawStructuredText, realPath), true);
     _lodash2.default.set(result, realPath, deserializedValue);
   }
@@ -3953,10 +3953,637 @@ var mcp_default = new (0, _interactivecommander.Command)().command("mcp").descri
   console.log("Lingo.dev MCP Server running on stdio");
 });
 
+// src/cli/cmd/ci.ts
+
+
+// ../../action/src/main.ts
+
+
+// ../../action/src/flows/pull-request.ts
+
+
+// ../../action/src/flows/in-branch.ts
+
+
+
+// ../../action/src/flows/_base.ts
+var IntegrationFlow = class {
+  constructor(ora, platformKit) {
+    this.ora = ora;
+    this.platformKit = platformKit;
+  }
+  
+};
+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");
+    _child_process.execSync.call(void 0, `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");
+      _child_process.execSync.call(void 0, `git add .`, { stdio: "inherit" });
+      _child_process.execSync.call(void 0, `git status --porcelain`, { stdio: "inherit" });
+      _child_process.execSync.call(void 0, `git commit -m "${this.platformKit.config.commitMessage}"`, {
+        stdio: "inherit"
+      });
+      this.ora.succeed("Changes committed");
+      this.ora.start("Pushing changes to remote");
+      const currentBranch = _nullishCoalesce(this.i18nBranchName, () => ( this.platformKit.platformConfig.baseBranchName));
+      _child_process.execSync.call(void 0, `git push origin ${currentBranch} ${forcePush ? "--force" : ""}`, {
+        stdio: "inherit"
+      });
+      this.ora.succeed("Changes pushed to remote");
+    }
+    return hasChanges;
+  }
+  checkCommitableChanges() {
+    return _child_process.execSync.call(void 0, 'git status --porcelain || echo "has_changes"', {
+      encoding: "utf8"
+    }).length > 0;
+  }
+  async runLingoDotDev() {
+    _child_process.execSync.call(void 0, `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:`);
+    _child_process.execSync.call(void 0, `pwd`, { stdio: "inherit" });
+    _child_process.execSync.call(void 0, `ls -la`, { stdio: "inherit" });
+    _child_process.execSync.call(void 0, `git config --global safe.directory ${process.cwd()}`);
+    _child_process.execSync.call(void 0, `git config user.name "${gitConfig.userName}"`);
+    _child_process.execSync.call(void 0, `git config user.email "${gitConfig.userEmail}"`);
+    _optionalChain([this, 'access', _146 => _146.platformKit, 'optionalAccess', _147 => _147.gitConfig, 'call', _148 => _148()]);
+    _child_process.execSync.call(void 0, `git fetch origin ${baseBranchName}`, { stdio: "inherit" });
+    _child_process.execSync.call(void 0, `git checkout ${baseBranchName} --`, { stdio: "inherit" });
+    if (!processOwnCommits) {
+      const currentAuthor = `${gitConfig.userName} <${gitConfig.userEmail}>`;
+      const authorOfLastCommit = _child_process.execSync.call(void 0, `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 = _path2.default.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 _optionalChain([super.preRun.bind(this), 'optionalCall', _149 => _149()]);
+    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) {
+    _child_process.execSync.call(void 0, `git fetch origin ${i18nBranchName}`, { stdio: "inherit" });
+    _child_process.execSync.call(void 0, `git checkout -b ${i18nBranchName}`, {
+      stdio: "inherit"
+    });
+  }
+  createI18nBranch(i18nBranchName) {
+    try {
+      _child_process.execSync.call(void 0, `git fetch origin ${this.platformKit.platformConfig.baseBranchName}`, { stdio: "inherit" });
+      _child_process.execSync.call(void 0, `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}`);
+    _child_process.execSync.call(void 0, `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");
+      _child_process.execSync.call(void 0, `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");
+      _child_process.execSync.call(void 0, "git rebase --abort", { stdio: "inherit" });
+      this.ora.succeed("Aborted failed rebase");
+      this.ora.start(`Resetting to ${this.platformKit.platformConfig.baseBranchName}`);
+      _child_process.execSync.call(void 0, `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 = _child_process.execSync.call(void 0, 
+        `npx lingo.dev@latest show files --target ${this.platformKit.platformConfig.baseBranchName}`,
+        { encoding: "utf8" }
+      ).split("\n").filter(Boolean);
+      targetFiles.push(...targetFileNames);
+      _child_process.execSync.call(void 0, `git fetch origin ${this.i18nBranchName}`, { stdio: "inherit" });
+      for (const file of targetFiles) {
+        try {
+          _child_process.execSync.call(void 0, `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) {
+      _child_process.execSync.call(void 0, "git add .", { stdio: "inherit" });
+      _child_process.execSync.call(void 0, `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
+
+var _bitbucket = require('bitbucket'); var _bitbucket2 = _interopRequireDefault(_bitbucket);
+
+
+// ../../action/src/platforms/_base.ts
+
+var defaultMessage = "feat: update translations via @lingodotdev";
+var PlatformKit = class {
+  gitConfig() {
+  }
+  get config() {
+    const env = _zod2.default.object({
+      LINGODOTDEV_API_KEY: _zod2.default.string(),
+      LINGODOTDEV_PULL_REQUEST: _zod2.default.preprocess((val) => val === "true" || val === true, _zod2.default.boolean()),
+      LINGODOTDEV_COMMIT_MESSAGE: _zod2.default.string().optional(),
+      LINGODOTDEV_PULL_REQUEST_TITLE: _zod2.default.string().optional(),
+      LINGODOTDEV_WORKING_DIRECTORY: _zod2.default.string().optional(),
+      LINGODOTDEV_PROCESS_OWN_COMMITS: _zod2.default.preprocess((val) => val === "true" || val === true, _zod2.default.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 } = _bitbucket2.default;
+var BitbucketPlatformKit = class extends PlatformKit {
+  
+  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 _optionalChain([values, 'optionalAccess', _150 => _150.find, 'call', _151 => _151(
+        ({ source, destination }) => _optionalChain([source, 'optionalAccess', _152 => _152.branch, 'optionalAccess', _153 => _153.name]) === branch && _optionalChain([destination, 'optionalAccess', _154 => _154.branch, 'optionalAccess', _155 => _155.name]) === this.platformConfig.baseBranchName
+      )]);
+    }).then((pr) => _optionalChain([pr, 'optionalAccess', _156 => _156.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 }) => _nullishCoalesce(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() {
+    _child_process.execSync.call(void 0, "git config --unset http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy", {
+      stdio: "inherit"
+    });
+    _child_process.execSync.call(void 0, "git config http.${BITBUCKET_GIT_HTTP_ORIGIN}.proxy http://host.docker.internal:29418/", {
+      stdio: "inherit"
+    });
+  }
+  get platformConfig() {
+    const env = _zod2.default.object({
+      BITBUCKET_BRANCH: _zod2.default.string(),
+      BITBUCKET_REPO_FULL_NAME: _zod2.default.string(),
+      BB_TOKEN: _zod2.default.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
+var _octokit2 = require('octokit');
+
+
+var GitHubPlatformKit = class extends PlatformKit {
+  
+  get octokit() {
+    if (!this._octokit) {
+      this._octokit = new (0, _octokit2.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) => _optionalChain([pr, 'optionalAccess', _157 => _157.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`;
+      _child_process.execSync.call(void 0, `git remote set-url origin ${url}`, {
+        stdio: "inherit"
+      });
+    }
+  }
+  get platformConfig() {
+    const env = _zod2.default.object({
+      GITHUB_REPOSITORY: _zod2.default.string(),
+      GITHUB_REPOSITORY_OWNER: _zod2.default.string(),
+      GITHUB_REF_NAME: _zod2.default.string(),
+      GITHUB_HEAD_REF: _zod2.default.string(),
+      GH_TOKEN: _zod2.default.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
+var _rest = require('@gitbeaker/rest');
+
+
+var gl = new (0, _rest.Gitlab)({ token: "" });
+var GitlabPlatformKit = class extends PlatformKit {
+  
+  constructor() {
+    super();
+    process.chdir(this.platformConfig.projectDir);
+  }
+  get gitlab() {
+    if (!this._gitlab) {
+      this._gitlab = new (0, _rest.Gitlab)({
+        token: this.platformConfig.glToken || ""
+      });
+    }
+    return this._gitlab;
+  }
+  get platformConfig() {
+    const env = _zod2.default.object({
+      GL_TOKEN: _zod2.default.string().optional(),
+      CI_COMMIT_BRANCH: _zod2.default.string(),
+      CI_MERGE_REQUEST_SOURCE_BRANCH_NAME: _zod2.default.string().optional(),
+      CI_PROJECT_NAMESPACE: _zod2.default.string(),
+      CI_PROJECT_NAME: _zod2.default.string(),
+      CI_PROJECT_ID: _zod2.default.string(),
+      CI_PROJECT_DIR: _zod2.default.string(),
+      CI_REPOSITORY_URL: _zod2.default.string()
+    }).parse(process.env);
+    const config = {
+      glToken: env.GL_TOKEN,
+      baseBranchName: _nullishCoalesce(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 (e2) {
+      return false;
+    }
+  }
+  async getOpenPullRequestNumber({ branch }) {
+    const mergeRequests = await this.gitlab.MergeRequests.all({
+      projectId: this.platformConfig.gitlabProjectId,
+      sourceBranch: branch,
+      state: "opened"
+    });
+    return _optionalChain([mergeRequests, 'access', _158 => _158[0], 'optionalAccess', _159 => _159.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`;
+    _child_process.execSync.call(void 0, `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 = _ora2.default.call(void 0, );
+  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 _optionalChain([flow, 'access', _160 => _160.preRun, 'optionalCall', _161 => _161()]);
+  if (canRun === false) {
+    return;
+  }
+  const hasChanges = await flow.run();
+  if (!hasChanges) {
+    return;
+  }
+  await _optionalChain([flow, 'access', _162 => _162.postRun, 'optionalCall', _163 => _163()]);
+}
+
+// src/cli/cmd/ci.ts
+var ci_default = new (0, _interactivecommander.Command)().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: _optionalChain([options, 'access', _164 => _164.pullRequest, 'optionalAccess', _165 => _165.toString, 'call', _166 => _166()]) || "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.16",
+  version: "0.79.0",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -4014,11 +4641,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 +4677,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 +4737,7 @@ ${_gradientstring.vice.call(void 0,
 
 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);
   }