@teambit/ci 0.0.0-01196c5baebfaeabe37f33253bb4c38b8b774ea8

package/dist/ci.main.runtime.js

@@ -0,0 +1,605 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CiMain = void 0;
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _workspace() {
+  const data = require("@teambit/workspace");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
+function _builder() {
+  const data = require("@teambit/builder");
+  _builder = function () {
+    return data;
+  };
+  return data;
+}
+function _status() {
+  const data = require("@teambit/status");
+  _status = function () {
+    return data;
+  };
+  return data;
+}
+function _lanes() {
+  const data = require("@teambit/lanes");
+  _lanes = function () {
+    return data;
+  };
+  return data;
+}
+function _snapping() {
+  const data = require("@teambit/snapping");
+  _snapping = function () {
+    return data;
+  };
+  return data;
+}
+function _export() {
+  const data = require("@teambit/export");
+  _export = function () {
+    return data;
+  };
+  return data;
+}
+function _importer() {
+  const data = require("@teambit/importer");
+  _importer = function () {
+    return data;
+  };
+  return data;
+}
+function _checkout() {
+  const data = require("@teambit/checkout");
+  _checkout = function () {
+    return data;
+  };
+  return data;
+}
+function _execa() {
+  const data = _interopRequireDefault(require("execa"));
+  _execa = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _ci() {
+  const data = require("./ci.aspect");
+  _ci = function () {
+    return data;
+  };
+  return data;
+}
+function _ci2() {
+  const data = require("./ci.cmd");
+  _ci2 = function () {
+    return data;
+  };
+  return data;
+}
+function _verify() {
+  const data = require("./commands/verify.cmd");
+  _verify = function () {
+    return data;
+  };
+  return data;
+}
+function _pr() {
+  const data = require("./commands/pr.cmd");
+  _pr = function () {
+    return data;
+  };
+  return data;
+}
+function _merge() {
+  const data = require("./commands/merge.cmd");
+  _merge = function () {
+    return data;
+  };
+  return data;
+}
+function _git() {
+  const data = require("./git");
+  _git = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class CiMain {
+  constructor(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config) {
+    this.workspace = workspace;
+    this.builder = builder;
+    this.status = status;
+    this.lanes = lanes;
+    this.snapping = snapping;
+    this.exporter = exporter;
+    this.importer = importer;
+    this.checkout = checkout;
+    this.logger = logger;
+    this.config = config;
+  }
+  static async provider([cli, workspace, loggerAspect, builder, status, lanes, snapping, exporter, importer, checkout], config) {
+    const logger = loggerAspect.createLogger(_ci().CiAspect.id);
+    const ci = new CiMain(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config);
+    const ciCmd = new (_ci2().CiCmd)(workspace, logger);
+    ciCmd.commands = [new (_verify().CiVerifyCmd)(workspace, logger, ci), new (_pr().CiPrCmd)(workspace, logger, ci), new (_merge().CiMergeCmd)(workspace, logger, ci)];
+    cli.register(ciCmd);
+    return ci;
+  }
+  async getBranchName() {
+    try {
+      // if we are running on github, use the GITHUB_HEAD_REF env var
+      if (process.env.GITHUB_HEAD_REF) return process.env.GITHUB_HEAD_REF;
+      const branch = await _git().git.branch();
+      return branch.current;
+    } catch (e) {
+      throw new Error(`Unable to read branch: ${e.toString()}`);
+    }
+  }
+  async getDefaultBranchName() {
+    try {
+      // Try to get the default branch from git symbolic-ref
+      const result = await _git().git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+      const defaultBranch = result.trim().split('/').pop();
+      return defaultBranch || 'master';
+    } catch (e) {
+      // Fallback to common default branch names
+      try {
+        const branches = await _git().git.branch(['-r']);
+        if (branches.all.includes('origin/main')) return 'main';
+        if (branches.all.includes('origin/master')) return 'master';
+        return 'master'; // Final fallback
+      } catch {
+        this.logger.console(_chalk().default.yellow(`Unable to detect default branch, using 'master': ${e.toString()}`));
+        return 'master';
+      }
+    }
+  }
+  async getGitCommitMessage() {
+    try {
+      const commit = await _git().git.log({
+        maxCount: 1
+      });
+      if (!commit.latest) {
+        return null;
+      }
+      const {
+        message,
+        body
+      } = commit.latest;
+      return body ? `${message}\n\n${body}` : message;
+    } catch (e) {
+      throw new Error(`Unable to read commit message: ${e.toString()}`);
+    }
+  }
+  parseVersionBumpFromCommit(commitMessage) {
+    // Check explicit bump keywords (highest priority after env vars)
+    if (this.config.useExplicitBumpKeywords !== false) {
+      // default to true
+      if (commitMessage.includes('BIT-BUMP-MAJOR')) {
+        this.logger.console(_chalk().default.blue('Found BIT-BUMP-MAJOR keyword in commit message'));
+        return 'major';
+      }
+      if (commitMessage.includes('BIT-BUMP-MINOR')) {
+        this.logger.console(_chalk().default.blue('Found BIT-BUMP-MINOR keyword in commit message'));
+        return 'minor';
+      }
+    }
+
+    // Check conventional commits if enabled
+    if (this.config.useConventionalCommitsForVersionBump) {
+      // Check for breaking changes (major version bump)
+      if (/^feat!(\(.+\))?:|^fix!(\(.+\))?:|BREAKING CHANGE/m.test(commitMessage)) {
+        this.logger.console(_chalk().default.blue('Found breaking changes in commit message (conventional commits)'));
+        return 'major';
+      }
+
+      // Check for features (minor version bump)
+      if (/^feat(\(.+\))?:/m.test(commitMessage)) {
+        this.logger.console(_chalk().default.blue('Found feature commits (conventional commits)'));
+        return 'minor';
+      }
+
+      // Check for fixes (patch version bump) - explicit patch not needed as it's default
+      if (/^fix(\(.+\))?:/m.test(commitMessage)) {
+        this.logger.console(_chalk().default.blue('Found fix commits (conventional commits) - using default patch'));
+        return 'patch';
+      }
+    }
+    return null; // No specific version bump detected
+  }
+  async getCustomCommitMessage() {
+    try {
+      const commitMessageScript = this.config.commitMessageScript;
+      if (commitMessageScript) {
+        this.logger.console(_chalk().default.blue(`Running custom commit message script: ${commitMessageScript}`));
+
+        // Parse the command to avoid shell injection
+        const parts = commitMessageScript.split(' ');
+        const command = parts[0];
+        const args = parts.slice(1);
+        const result = await (0, _execa().default)(command, args, {
+          cwd: this.workspace.path,
+          encoding: 'utf8'
+        });
+        const customMessage = result.stdout.trim();
+        if (customMessage) {
+          this.logger.console(_chalk().default.green(`Using custom commit message: ${customMessage}`));
+          return customMessage;
+        }
+      }
+    } catch (e) {
+      this.logger.console(_chalk().default.yellow(`Failed to run custom commit message script: ${e.toString()}`));
+    }
+
+    // Fallback to default message
+    return 'chore: update .bitmap and lockfiles as needed [skip ci]';
+  }
+  async verifyWorkspaceStatusInternal(strict = false) {
+    this.logger.console('📊 Workspace Status');
+    this.logger.console(_chalk().default.blue('Verifying status of workspace'));
+    const status = await this.status.status({
+      lanes: true
+    });
+    const {
+      data: statusOutput,
+      code
+    } = await this.status.formatStatusOutput(status, strict ? {
+      strict: true,
+      warnings: true
+    } // When strict=true, fail on both errors and warnings
+    : {
+      failOnError: true,
+      warnings: false
+    } // By default, fail only on errors (tag blockers)
+    );
+
+    // Log the formatted status output
+    this.logger.console(statusOutput);
+    if (code !== 0) {
+      throw new Error('Workspace status verification failed');
+    }
+    this.logger.consoleSuccess(_chalk().default.green('Workspace status is correct'));
+    return {
+      status
+    };
+  }
+  async switchToLane(laneName, options = {}) {
+    this.logger.console(_chalk().default.blue(`Switching to ${laneName}`));
+    await this.lanes.switchLanes(laneName, _objectSpread({
+      forceOurs: true,
+      head: true,
+      workspaceOnly: true,
+      skipDependencyInstallation: true
+    }, options)).catch(e => {
+      if (e.toString().includes('already checked out')) {
+        this.logger.console(_chalk().default.yellow(`Lane ${laneName} already checked out, skipping checkout`));
+        return true;
+      }
+      this.logger.console(_chalk().default.red(`Failed to checkout lane ${laneName}: ${e.toString()}`));
+      return null;
+    });
+  }
+  async verifyWorkspaceStatus() {
+    await this.verifyWorkspaceStatusInternal();
+    this.logger.console('🔨 Build Process');
+    const components = await this.workspace.list();
+    this.logger.console(_chalk().default.blue(`Building ${components.length} components`));
+    const build = await this.builder.build(components);
+    build.throwErrorsIfExist();
+    this.logger.console(_chalk().default.green('Components built'));
+    return {
+      code: 0,
+      data: ''
+    };
+  }
+  async snapPrCommit({
+    laneIdStr,
+    message,
+    build,
+    strict
+  }) {
+    this.logger.console(_chalk().default.blue(`Lane name: ${laneIdStr}`));
+    const originalLane = await this.lanes.getCurrentLane();
+    const laneId = await this.lanes.parseLaneId(laneIdStr);
+    await this.verifyWorkspaceStatusInternal(strict);
+    await this.importer.import({
+      ids: [],
+      installNpmPackages: false,
+      writeConfigFiles: false
+    }).catch(e => {
+      throw new Error(`Failed to import components: ${e.toString()}`);
+    });
+    this.logger.console('🔄 Lane Management');
+    const availableLanesInScope = await this.lanes.getLanes({
+      remote: laneId.scope
+    }).catch(e => {
+      throw new Error(`Failed to get lanes in scope ${laneId.scope}: ${e.toString()}`);
+    });
+    const laneExists = availableLanesInScope.find(lane => lane.id.name === laneId.name);
+    let foundErr;
+    try {
+      if (laneExists) {
+        const lane = await this.lanes.importLaneObject(laneId, true);
+        this.workspace.consumer.setCurrentLane(laneId, true);
+        const laneIds = lane.toComponentIds();
+        laneIds.forEach(compId => this.workspace.consumer.bitMap.updateComponentId(compId));
+        await this.workspace.bitMap.write();
+        await this.importer.importCurrentObjects();
+        this.logger.console(_chalk().default.green(`Imported lane ${laneId.toString()}`));
+      } else {
+        this.logger.console(_chalk().default.blue(`Creating lane ${laneId.toString()}`));
+        try {
+          await this.lanes.createLane(laneId.name, {
+            scope: laneId.scope,
+            forkLaneNewScope: true
+          });
+        } catch (e) {
+          if (e.message.includes('already exists')) {
+            this.logger.console(_chalk().default.yellow(`Lane ${laneId.toString()} already exists, skipping creation`));
+          } else {
+            throw new Error(`Failed to create lane ${laneId.toString()}: ${e.toString()}`);
+          }
+        }
+      }
+      const currentLane = await this.lanes.getCurrentLane();
+      this.logger.console(_chalk().default.blue(`Current lane: ${currentLane?.name ?? 'main'}`));
+      if (currentLane?.name === laneId.name) {
+        this.logger.console(_chalk().default.yellow(`Current lane is already ${laneId.name}, skipping switch`));
+      } else {
+        await this.switchToLane(laneId.toString());
+      }
+      this.logger.console('📦 Snapping Components');
+      const results = await this.snapping.snap({
+        message,
+        build,
+        exitOnFirstFailedTask: true
+      });
+      if (!results) {
+        return 'No changes detected, nothing to snap';
+      }
+      const {
+        snappedComponents
+      } = results;
+      const snapOutput = (0, _snapping().snapResultOutput)(results);
+      this.logger.console(snapOutput);
+      this.logger.console(_chalk().default.blue(`Exporting ${snappedComponents.length} components`));
+      const exportResults = await this.exporter.export();
+      this.logger.console(_chalk().default.green(`Exported ${exportResults.componentsIds.length} components`));
+    } catch (e) {
+      foundErr = e;
+      throw e;
+    } finally {
+      if (foundErr) {
+        this.logger.console(_chalk().default.red(`Found error: ${foundErr.message}`));
+      }
+      // Whatever happens, switch back to the original lane
+      this.logger.console('🔄 Cleanup');
+      this.logger.console(_chalk().default.blue(`Switching back to ${originalLane?.name ?? 'main'}`));
+      const lane = await this.lanes.getCurrentLane();
+      if (!lane) {
+        this.logger.console(_chalk().default.yellow('Already on main, no need to switch. Checking out to head'));
+        await this.lanes.checkout.checkout({
+          head: true,
+          skipNpmInstall: true
+        });
+      } else {
+        await this.switchToLane(originalLane?.name ?? 'main');
+      }
+    }
+  }
+  async mergePr({
+    message: argMessage,
+    build,
+    strict,
+    releaseType,
+    preReleaseId,
+    incrementBy,
+    explicitVersionBump,
+    verbose
+  }) {
+    const message = argMessage || (await this.getGitCommitMessage());
+    if (!message) {
+      throw new Error('Failed to get commit message from git. Please provide a message using --message option.');
+    }
+    const currentLane = await this.lanes.getCurrentLane();
+    if (currentLane) {
+      // this doesn't normally happen. we expect this mergePr to be called from the default branch, which normally checks
+      // out to main lane.
+      this.logger.console(_chalk().default.blue(`Currently on lane ${currentLane.name}, switching to main`));
+      await this.switchToLane('main');
+      this.logger.console(_chalk().default.green('Switched to main lane'));
+    }
+
+    // Pull latest changes from remote to ensure we have the most up-to-date .bitmap
+    // This prevents issues when multiple PRs are merged in sequence
+    const defaultBranch = await this.getDefaultBranchName();
+    this.logger.console(_chalk().default.blue(`Pulling latest git changes from ${defaultBranch} branch`));
+
+    // Check if there are any changes to stash before rebasing
+    const gitStatus = await _git().git.status();
+    const hasChanges = gitStatus.files.length > 0;
+    if (hasChanges) {
+      this.logger.console(_chalk().default.yellow('Stashing uncommitted changes before rebase'));
+      await _git().git.stash(['push', '-u', '-m', 'CI merge temporary stash']);
+    }
+    await _git().git.pull('origin', defaultBranch, {
+      '--rebase': 'true'
+    });
+    if (hasChanges) {
+      this.logger.console(_chalk().default.yellow('Restoring stashed changes after rebase'));
+      await _git().git.stash(['pop']);
+    }
+    this.logger.console(_chalk().default.green('Pulled latest git changes'));
+    this.logger.console('🔄 Checking out to main head');
+    await this.importer.importCurrentObjects();
+    const checkoutProps = {
+      forceOurs: true,
+      head: true,
+      skipNpmInstall: true
+    };
+    const checkoutResults = await this.checkout.checkout(checkoutProps);
+    await this.workspace.bitMap.write('checkout head');
+    this.logger.console((0, _checkout().checkoutOutput)(checkoutResults, checkoutProps));
+    const {
+      status
+    } = await this.verifyWorkspaceStatusInternal(strict);
+    const hasSoftTaggedComponents = status.softTaggedComponents.length > 0;
+    this.logger.console('📦 Component Operations');
+    this.logger.console(_chalk().default.blue('Tagging components'));
+    const finalReleaseType = await this.determineReleaseType(releaseType, explicitVersionBump);
+    const tagResults = await this.snapping.tag({
+      all: true,
+      message,
+      build,
+      failFast: true,
+      persist: hasSoftTaggedComponents,
+      releaseType: finalReleaseType,
+      preReleaseId,
+      incrementBy
+    });
+    if (tagResults) {
+      const tagOutput = (0, _snapping().tagResultOutput)(tagResults);
+      this.logger.console(tagOutput);
+    } else {
+      this.logger.console(_chalk().default.yellow('No components to tag'));
+    }
+    const hasTaggedComponents = tagResults?.taggedComponents && tagResults.taggedComponents.length > 0;
+    if (hasTaggedComponents) {
+      this.logger.console(_chalk().default.blue('Exporting components'));
+      const exportResult = await this.exporter.export();
+      if (exportResult.componentsIds.length > 0) {
+        this.logger.console(_chalk().default.green(`Exported ${exportResult.componentsIds.length} component(s)`));
+      } else {
+        this.logger.console(_chalk().default.yellow('Nothing to export'));
+      }
+      this.logger.console('🔄 Git Operations');
+      // Set user.email and user.name
+      await _git().git.addConfig('user.email', 'bit-ci[bot]@bit.cloud');
+      await _git().git.addConfig('user.name', 'Bit CI');
+
+      // Check git status before commit
+      const statusBeforeCommit = await _git().git.status();
+      this.logger.console(_chalk().default.blue(`Git status before commit: ${statusBeforeCommit.files.length} files`));
+      statusBeforeCommit.files.forEach(file => {
+        this.logger.console(_chalk().default.gray(`  ${file.working_dir}${file.index} ${file.path}`));
+      });
+
+      // Show git diff if there are uncommitted changes
+      if (verbose && statusBeforeCommit.files.length > 0) {
+        try {
+          const diff = await _git().git.diff();
+          if (diff) {
+            this.logger.console(_chalk().default.blue('Git diff before commit:'));
+            this.logger.console(diff);
+          }
+        } catch (error) {
+          this.logger.console(_chalk().default.yellow(`Failed to show git diff: ${error}`));
+        }
+      }
+
+      // Previously we committed only .bitmap and pnpm-lock.yaml files.
+      // However, it's possible that "bit checkout head" we did above, modified other files as well.
+      // So now we commit all files that were changed.
+      await _git().git.add(['.']);
+      const commitMessage = await this.getCustomCommitMessage();
+      await _git().git.commit(commitMessage);
+
+      // Check git status after commit
+      const statusAfterCommit = await _git().git.status();
+      this.logger.console(_chalk().default.blue(`Git status after commit: ${statusAfterCommit.files.length} files`));
+      statusAfterCommit.files.forEach(file => {
+        this.logger.console(_chalk().default.gray(`  ${file.working_dir}${file.index} ${file.path}`));
+      });
+      await _git().git.pull('origin', defaultBranch, {
+        '--rebase': 'true'
+      });
+      await _git().git.push('origin', defaultBranch);
+    } else {
+      this.logger.console(_chalk().default.yellow('No components were tagged, skipping export and git operations'));
+    }
+    this.logger.console(_chalk().default.green('Merged PR'));
+    if (currentLane) {
+      this.logger.console('🗑️ Lane Cleanup');
+      const laneId = currentLane.id();
+      this.logger.console(_chalk().default.blue(`Archiving lane ${laneId}`));
+      // force means to remove the lane even if it was not merged. in this case, we don't care much because main already has the changes.
+      const archiveLane = await this.lanes.removeLanes([laneId], {
+        remote: true,
+        force: true
+      });
+      if (archiveLane.length) {
+        this.logger.console(_chalk().default.green('Lane archived'));
+      } else {
+        this.logger.console(_chalk().default.yellow('Failed to archive lane'));
+      }
+    }
+    return {
+      code: 0,
+      data: ''
+    };
+  }
+
+  /**
+   * Auto-detect version bump from commit messages if no explicit version bump was provided
+   */
+  async determineReleaseType(releaseType, explicitVersionBump) {
+    if (explicitVersionBump) {
+      this.logger.console(_chalk().default.blue(`Using explicit version bump: ${releaseType}`));
+      return releaseType;
+    }
+    // Only auto-detect if user didn't specify any version flags
+    const lastCommit = await this.getGitCommitMessage();
+    if (!lastCommit) {
+      this.logger.console(_chalk().default.blue('No commit message found, using default patch'));
+      return releaseType;
+    }
+    const detectedReleaseType = this.parseVersionBumpFromCommit(lastCommit);
+    if (detectedReleaseType) {
+      this.logger.console(_chalk().default.green(`Auto-detected version bump: ${detectedReleaseType}`));
+      return detectedReleaseType;
+    }
+    this.logger.console(_chalk().default.blue('No specific version bump detected, using default patch'));
+    return releaseType;
+  }
+}
+
+// @ts-ignore
+exports.CiMain = CiMain;
+_defineProperty(CiMain, "runtime", _cli().MainRuntime);
+_defineProperty(CiMain, "dependencies", [_cli().CLIAspect, _workspace().WorkspaceAspect, _logger().LoggerAspect, _builder().BuilderAspect, _status().StatusAspect, _lanes().LanesAspect, _snapping().SnappingAspect, _export().ExportAspect, _importer().ImporterAspect, _checkout().CheckoutAspect]);
+_defineProperty(CiMain, "slots", []);
+_ci().CiAspect.addRuntime(CiMain);
+
+//# sourceMappingURL=ci.main.runtime.js.map