@teambit/cli 0.0.0-00805bd6ead01ffad26e598a8de15824e876ee5a

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { CLIAspect, MainRuntime } from './cli.aspect';
+import globalFlags from './global-flags';
+import defaultErrorHandler from './default-error-handler';
+export { CLIParser } from './cli-parser';
+export type { CLIMain, CommandList, CommandsSlot } from './cli.main.runtime';
+export { handleUnhandledRejection, handleErrorAndExit, setExitOnUnhandledRejection } from './handle-errors';
+export { globalFlags };
+export { defaultErrorHandler };
+export type { Command, CLIArgs, Flags, GenericObject, CommandOptions, Report } from './command';
+export { getArgsData, getCommandName, getFlagsData } from './command-helper';
+export * from './exceptions';
+export { successSymbol, warnSymbol, errorSymbol, bulletSymbol, formatItem, formatSection, formatTitle, formatHint, formatDetailsHint, formatSuccessSummary, formatWarningSummary, joinSections, renderSections, } from './output-formatter';
+export type { OutputSection } from './output-formatter';
+export { CLIAspect as default, MainRuntime, CLIAspect };

package/dist/index.js

@@ -0,0 +1,245 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  CLIAspect: true,
+  MainRuntime: true,
+  globalFlags: true,
+  defaultErrorHandler: true,
+  CLIParser: true,
+  handleUnhandledRejection: true,
+  handleErrorAndExit: true,
+  setExitOnUnhandledRejection: true,
+  getArgsData: true,
+  getCommandName: true,
+  getFlagsData: true,
+  successSymbol: true,
+  warnSymbol: true,
+  errorSymbol: true,
+  bulletSymbol: true,
+  formatItem: true,
+  formatSection: true,
+  formatTitle: true,
+  formatHint: true,
+  formatDetailsHint: true,
+  formatSuccessSummary: true,
+  formatWarningSummary: true,
+  joinSections: true,
+  renderSections: true
+};
+Object.defineProperty(exports, "CLIAspect", {
+  enumerable: true,
+  get: function () {
+    return _cli().CLIAspect;
+  }
+});
+Object.defineProperty(exports, "CLIParser", {
+  enumerable: true,
+  get: function () {
+    return _cliParser().CLIParser;
+  }
+});
+Object.defineProperty(exports, "MainRuntime", {
+  enumerable: true,
+  get: function () {
+    return _cli().MainRuntime;
+  }
+});
+Object.defineProperty(exports, "bulletSymbol", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().bulletSymbol;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _cli().CLIAspect;
+  }
+});
+Object.defineProperty(exports, "defaultErrorHandler", {
+  enumerable: true,
+  get: function () {
+    return _defaultErrorHandler().default;
+  }
+});
+Object.defineProperty(exports, "errorSymbol", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().errorSymbol;
+  }
+});
+Object.defineProperty(exports, "formatDetailsHint", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatDetailsHint;
+  }
+});
+Object.defineProperty(exports, "formatHint", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatHint;
+  }
+});
+Object.defineProperty(exports, "formatItem", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatItem;
+  }
+});
+Object.defineProperty(exports, "formatSection", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatSection;
+  }
+});
+Object.defineProperty(exports, "formatSuccessSummary", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatSuccessSummary;
+  }
+});
+Object.defineProperty(exports, "formatTitle", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatTitle;
+  }
+});
+Object.defineProperty(exports, "formatWarningSummary", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().formatWarningSummary;
+  }
+});
+Object.defineProperty(exports, "getArgsData", {
+  enumerable: true,
+  get: function () {
+    return _commandHelper().getArgsData;
+  }
+});
+Object.defineProperty(exports, "getCommandName", {
+  enumerable: true,
+  get: function () {
+    return _commandHelper().getCommandName;
+  }
+});
+Object.defineProperty(exports, "getFlagsData", {
+  enumerable: true,
+  get: function () {
+    return _commandHelper().getFlagsData;
+  }
+});
+Object.defineProperty(exports, "globalFlags", {
+  enumerable: true,
+  get: function () {
+    return _globalFlags().default;
+  }
+});
+Object.defineProperty(exports, "handleErrorAndExit", {
+  enumerable: true,
+  get: function () {
+    return _handleErrors().handleErrorAndExit;
+  }
+});
+Object.defineProperty(exports, "handleUnhandledRejection", {
+  enumerable: true,
+  get: function () {
+    return _handleErrors().handleUnhandledRejection;
+  }
+});
+Object.defineProperty(exports, "joinSections", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().joinSections;
+  }
+});
+Object.defineProperty(exports, "renderSections", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().renderSections;
+  }
+});
+Object.defineProperty(exports, "setExitOnUnhandledRejection", {
+  enumerable: true,
+  get: function () {
+    return _handleErrors().setExitOnUnhandledRejection;
+  }
+});
+Object.defineProperty(exports, "successSymbol", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().successSymbol;
+  }
+});
+Object.defineProperty(exports, "warnSymbol", {
+  enumerable: true,
+  get: function () {
+    return _outputFormatter().warnSymbol;
+  }
+});
+function _cli() {
+  const data = require("./cli.aspect");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _globalFlags() {
+  const data = _interopRequireDefault(require("./global-flags"));
+  _globalFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _defaultErrorHandler() {
+  const data = _interopRequireDefault(require("./default-error-handler"));
+  _defaultErrorHandler = function () {
+    return data;
+  };
+  return data;
+}
+function _cliParser() {
+  const data = require("./cli-parser");
+  _cliParser = function () {
+    return data;
+  };
+  return data;
+}
+function _handleErrors() {
+  const data = require("./handle-errors");
+  _handleErrors = function () {
+    return data;
+  };
+  return data;
+}
+function _commandHelper() {
+  const data = require("./command-helper");
+  _commandHelper = function () {
+    return data;
+  };
+  return data;
+}
+var _exceptions = require("./exceptions");
+Object.keys(_exceptions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _exceptions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _exceptions[key];
+    }
+  });
+});
+function _outputFormatter() {
+  const data = require("./output-formatter");
+  _outputFormatter = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_cli","data","require","_globalFlags","_interopRequireDefault","_defaultErrorHandler","_cliParser","_handleErrors","_commandHelper","_exceptions","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_outputFormatter","e","__esModule","default"],"sources":["index.ts"],"sourcesContent":["import { CLIAspect, MainRuntime } from './cli.aspect';\nimport globalFlags from './global-flags';\nimport defaultErrorHandler from './default-error-handler';\nexport { CLIParser } from './cli-parser';\nexport type { CLIMain, CommandList, CommandsSlot } from './cli.main.runtime';\nexport { handleUnhandledRejection, handleErrorAndExit, setExitOnUnhandledRejection } from './handle-errors';\nexport { globalFlags };\nexport { defaultErrorHandler };\nexport type { Command, CLIArgs, Flags, GenericObject, CommandOptions, Report } from './command';\nexport { getArgsData, getCommandName, getFlagsData } from './command-helper';\nexport * from './exceptions';\n\nexport {\n  successSymbol,\n  warnSymbol,\n  errorSymbol,\n  bulletSymbol,\n  formatItem,\n  formatSection,\n  formatTitle,\n  formatHint,\n  formatDetailsHint,\n  formatSuccessSummary,\n  formatWarningSummary,\n  joinSections,\n  renderSections,\n} from './output-formatter';\nexport type { OutputSection } from './output-formatter';\n\nexport { CLIAspect as default, MainRuntime, CLIAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,KAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,IAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,aAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,YAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,qBAAA;EAAA,MAAAJ,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAG,oBAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,WAAA;EAAA,MAAAL,IAAA,GAAAC,OAAA;EAAAI,UAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAM,cAAA;EAAA,MAAAN,IAAA,GAAAC,OAAA;EAAAK,aAAA,YAAAA,CAAA;IAAA,OAAAN,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIA,SAAAO,eAAA;EAAA,MAAAP,IAAA,GAAAC,OAAA;EAAAM,cAAA,YAAAA,CAAA;IAAA,OAAAP,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,IAAAQ,WAAA,GAAAP,OAAA;AAAAQ,MAAA,CAAAC,IAAA,CAAAF,WAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,WAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,WAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,SAAAS,iBAAA;EAAA,MAAArB,IAAA,GAAAC,OAAA;EAAAoB,gBAAA,YAAAA,CAAA;IAAA,OAAArB,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAc4B,SAAAG,uBAAAmB,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}

package/dist/output-formatter.d.ts

@@ -0,0 +1,40 @@
+export declare function successSymbol(): string;
+/** Yellow warning symbol */
+export declare const warnSymbol: string;
+/** Red error symbol */
+export declare const errorSymbol: string;
+/** Neutral bullet for informational items (no success/failure connotation) */
+export declare const bulletSymbol: string;
+/** Format a single item with 3-space indent + symbol + text. Defaults to bullet symbol. */
+export declare function formatItem(text: string, symbol?: string): string;
+/**
+ * Format a section with bold white title (including item count), dim description, and items.
+ * Returns empty string if items array is empty.
+ */
+export declare function formatSection(title: string, description: string, items: string[]): string;
+/** Format a bold white section title */
+export declare function formatTitle(text: string): string;
+/** Format hint text in dim color */
+export declare function formatHint(text: string): string;
+/** Format a hint pointing the user to `bit details` for expanded output */
+export declare function formatDetailsHint(subject?: string): string;
+/** Format a success summary: green checkmark + green message */
+export declare function formatSuccessSummary(msg: string): string;
+/** Format a warning summary: warning symbol + yellow message */
+export declare function formatWarningSummary(msg: string): string;
+/** Filter out empty strings and join remaining sections with double newlines */
+export declare function joinSections(sections: string[]): string;
+export interface OutputSection {
+    /** The fully rendered section text */
+    content: string;
+    /** If set, this section starts collapsed. Use --expand to show full content. */
+    collapsible?: {
+        /** Summary line shown when collapsed */
+        summary: string;
+    };
+}
+/**
+ * Render sections to a string, collapsing sections that are marked collapsible.
+ * When expand is true, all sections are shown expanded.
+ */
+export declare function renderSections(sections: OutputSection[], expand?: boolean): string;

package/dist/output-formatter.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorSymbol = exports.bulletSymbol = void 0;
+exports.formatDetailsHint = formatDetailsHint;
+exports.formatHint = formatHint;
+exports.formatItem = formatItem;
+exports.formatSection = formatSection;
+exports.formatSuccessSummary = formatSuccessSummary;
+exports.formatTitle = formatTitle;
+exports.formatWarningSummary = formatWarningSummary;
+exports.joinSections = joinSections;
+exports.renderSections = renderSections;
+exports.successSymbol = successSymbol;
+exports.warnSymbol = void 0;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _os() {
+  const data = require("os");
+  _os = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** Cross-platform green checkmark (mirrors Logger.successSymbol without importing Logger to avoid coupling) */
+const _successSymbol = (0, _os().platform)() === 'win32' ? _chalk().default.green('\u2713') : _chalk().default.green('\u2714');
+function successSymbol() {
+  return _successSymbol;
+}
+
+/** Yellow warning symbol */
+const warnSymbol = exports.warnSymbol = _chalk().default.yellow('\u26A0');
+
+/** Red error symbol */
+const errorSymbol = exports.errorSymbol = _chalk().default.red('\u2716');
+
+/** Neutral bullet for informational items (no success/failure connotation) */
+const bulletSymbol = exports.bulletSymbol = _chalk().default.dim('\u203A');
+
+/** Format a single item with 3-space indent + symbol + text. Defaults to bullet symbol. */
+function formatItem(text, symbol) {
+  const s = symbol ?? bulletSymbol;
+  return `   ${s} ${text}`;
+}
+
+/**
+ * Format a section with bold white title (including item count), dim description, and items.
+ * Returns empty string if items array is empty.
+ */
+function formatSection(title, description, items) {
+  if (!items.length) return '';
+  const lines = [formatTitle(`${title} (${items.length})`)];
+  if (description) {
+    const indented = description.split('\n').map(l => `  ${l}`).join('\n');
+    lines.push(_chalk().default.dim(indented));
+  }
+  lines.push(...items);
+  return lines.join('\n');
+}
+
+/** Format a bold white section title */
+function formatTitle(text) {
+  return _chalk().default.bold.white(text);
+}
+
+/** Format hint text in dim color */
+function formatHint(text) {
+  return _chalk().default.dim(text);
+}
+
+/** Format a hint pointing the user to `bit details` for expanded output */
+function formatDetailsHint(subject) {
+  const what = subject ? ` ${subject}` : '';
+  return formatHint(`(run "bit details" to see${what})`);
+}
+
+/** Format a success summary: green checkmark + green message */
+function formatSuccessSummary(msg) {
+  return `${successSymbol()} ${_chalk().default.green(msg)}`;
+}
+
+/** Format a warning summary: warning symbol + yellow message */
+function formatWarningSummary(msg) {
+  return `${warnSymbol} ${_chalk().default.yellow(msg)}`;
+}
+
+/** Filter out empty strings and join remaining sections with double newlines */
+function joinSections(sections) {
+  return sections.filter(Boolean).join('\n\n');
+}
+/**
+ * Render sections to a string, collapsing sections that are marked collapsible.
+ * When expand is true, all sections are shown expanded.
+ */
+function renderSections(sections, expand = false) {
+  const parts = [];
+  for (const section of sections) {
+    if (section.collapsible && !expand) {
+      parts.push(section.collapsible.summary);
+    } else if (section.content) {
+      parts.push(section.content);
+    }
+  }
+  return parts.filter(Boolean).join('\n\n');
+}
+
+//# sourceMappingURL=output-formatter.js.map

package/dist/output-formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chalk","data","_interopRequireDefault","require","_os","e","__esModule","default","_successSymbol","platform","chalk","green","successSymbol","warnSymbol","exports","yellow","errorSymbol","red","bulletSymbol","dim","formatItem","text","symbol","s","formatSection","title","description","items","length","lines","formatTitle","indented","split","map","l","join","push","bold","white","formatHint","formatDetailsHint","subject","what","formatSuccessSummary","msg","formatWarningSummary","joinSections","sections","filter","Boolean","renderSections","expand","parts","section","collapsible","summary","content"],"sources":["output-formatter.ts"],"sourcesContent":["import chalk from 'chalk';\nimport { platform } from 'os';\n\n/** Cross-platform green checkmark (mirrors Logger.successSymbol without importing Logger to avoid coupling) */\nconst _successSymbol = platform() === 'win32' ? chalk.green('\\u2713') : chalk.green('\\u2714');\nexport function successSymbol(): string {\n  return _successSymbol;\n}\n\n/** Yellow warning symbol */\nexport const warnSymbol = chalk.yellow('\\u26A0');\n\n/** Red error symbol */\nexport const errorSymbol = chalk.red('\\u2716');\n\n/** Neutral bullet for informational items (no success/failure connotation) */\nexport const bulletSymbol = chalk.dim('\\u203A');\n\n/** Format a single item with 3-space indent + symbol + text. Defaults to bullet symbol. */\nexport function formatItem(text: string, symbol?: string): string {\n  const s = symbol ?? bulletSymbol;\n  return `   ${s} ${text}`;\n}\n\n/**\n * Format a section with bold white title (including item count), dim description, and items.\n * Returns empty string if items array is empty.\n */\nexport function formatSection(title: string, description: string, items: string[]): string {\n  if (!items.length) return '';\n  const lines: string[] = [formatTitle(`${title} (${items.length})`)];\n  if (description) {\n    const indented = description\n      .split('\\n')\n      .map((l) => `  ${l}`)\n      .join('\\n');\n    lines.push(chalk.dim(indented));\n  }\n  lines.push(...items);\n  return lines.join('\\n');\n}\n\n/** Format a bold white section title */\nexport function formatTitle(text: string): string {\n  return chalk.bold.white(text);\n}\n\n/** Format hint text in dim color */\nexport function formatHint(text: string): string {\n  return chalk.dim(text);\n}\n\n/** Format a hint pointing the user to `bit details` for expanded output */\nexport function formatDetailsHint(subject?: string): string {\n  const what = subject ? ` ${subject}` : '';\n  return formatHint(`(run \"bit details\" to see${what})`);\n}\n\n/** Format a success summary: green checkmark + green message */\nexport function formatSuccessSummary(msg: string): string {\n  return `${successSymbol()} ${chalk.green(msg)}`;\n}\n\n/** Format a warning summary: warning symbol + yellow message */\nexport function formatWarningSummary(msg: string): string {\n  return `${warnSymbol} ${chalk.yellow(msg)}`;\n}\n\n/** Filter out empty strings and join remaining sections with double newlines */\nexport function joinSections(sections: string[]): string {\n  return sections.filter(Boolean).join('\\n\\n');\n}\n\nexport interface OutputSection {\n  /** The fully rendered section text */\n  content: string;\n  /** If set, this section starts collapsed. Use --expand to show full content. */\n  collapsible?: {\n    /** Summary line shown when collapsed */\n    summary: string;\n  };\n}\n\n/**\n * Render sections to a string, collapsing sections that are marked collapsible.\n * When expand is true, all sections are shown expanded.\n */\nexport function renderSections(sections: OutputSection[], expand = false): string {\n  const parts: string[] = [];\n  for (const section of sections) {\n    if (section.collapsible && !expand) {\n      parts.push(section.collapsible.summary);\n    } else if (section.content) {\n      parts.push(section.content);\n    }\n  }\n  return parts.filter(Boolean).join('\\n\\n');\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/pager.d.ts

@@ -0,0 +1,35 @@
+import type { Command, Flags } from './command';
+/**
+ * detect whether the output is going to an interactive human terminal.
+ * anything non-interactive (piped output, CI, ai-agents, bit-cli-server) gets the full output
+ * with no pager.
+ */
+export declare function isInteractiveTerminal(): boolean;
+/**
+ * whether the output already fits within the current terminal, in which case there's no reason
+ * to page it (avoids the "press q to exit" annoyance for short output, without relying on the
+ * version-dependent `less -F` behavior which is broken by `-X` in modern less). accounts for line
+ * wrapping and ignores ansi color codes when measuring width. returns false when the terminal size
+ * is unknown.
+ */
+export declare function fitsOnScreen(output: string): boolean;
+/**
+ * decide whether a command's report output should be piped through a pager.
+ * mirrors git: on by default for interactive terminals, off for anything else. explicit flags
+ * (--pager / --no-pager) and the BIT_NO_PAGER env var override the automatic behavior. in the
+ * automatic case, output that already fits on the screen is printed directly (no pager).
+ */
+export declare function shouldUsePager(command: Command, flags: Flags, output: string): boolean;
+/**
+ * pipe the given output through a pager (`less` by default). resolves to `true` only after the
+ * pager process has exited cleanly — the caller must await this before exiting the process so the
+ * pager isn't cut off. resolves to `false` when paging is disabled, the pager couldn't launch, or
+ * it exited with an error, in which case the caller must write the data directly so nothing is lost.
+ *
+ * the pager binary is taken from BIT_PAGER, then PAGER, defaulting to `less`. an empty or `cat`
+ * pager means the user disabled paging via the env — honored unless `force` is set (the `--pager`
+ * flag), which falls back to a real pager so the flag is a true override. for `less` we set
+ * `LESS=FRX` (unless already set, matching git's default): keep ansi colors (-R), don't clear the
+ * screen on exit (-X), and quit if the output fits one screen (-F).
+ */
+export declare function writeToPager(data: string, force?: boolean): Promise<boolean>;

package/dist/pager.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fitsOnScreen = fitsOnScreen;
+exports.isInteractiveTerminal = isInteractiveTerminal;
+exports.shouldUsePager = shouldUsePager;
+exports.writeToPager = writeToPager;
+function _child_process() {
+  const data = require("child_process");
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.logger");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.utils");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+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); }
+/**
+ * best-effort list of env vars set by ai-agent / automation runners. when any is present we
+ * never page, so agents always receive the full command output at once (never partial/paged
+ * data), even in the rare case they allocate a pseudo-tty.
+ */
+const AI_AGENT_ENV_VARS = ['CLAUDECODE', 'CLAUDE_CODE', 'CURSOR_AGENT'];
+
+/**
+ * an env var counts as "set" when it's present at all, even if its value is an empty string. the
+ * vars we gate on (CI, ai-agent markers, BIT_NO_PAGER) are opt-outs, so presence — not truthiness —
+ * is what disables paging; this also matches automation runners that inject empty-string values.
+ */
+const isEnvSet = name => process.env[name] !== undefined;
+
+/**
+ * detect whether the output is going to an interactive human terminal.
+ * anything non-interactive (piped output, CI, ai-agents, bit-cli-server) gets the full output
+ * with no pager.
+ */
+function isInteractiveTerminal() {
+  if (!process.stdout.isTTY) return false;
+  // daemon contexts don't page: the bit-cli-server (output travels over IPC, no terminal) and the
+  // experimental `bit cli` REPL (a pager would fight its readline interface over the TTY).
+  if (_legacy().logger.isDaemon) return false;
+  if (isEnvSet('CI')) return false;
+  if (AI_AGENT_ENV_VARS.some(isEnvSet)) return false;
+  return true;
+}
+
+/**
+ * whether the output already fits within the current terminal, in which case there's no reason
+ * to page it (avoids the "press q to exit" annoyance for short output, without relying on the
+ * version-dependent `less -F` behavior which is broken by `-X` in modern less). accounts for line
+ * wrapping and ignores ansi color codes when measuring width. returns false when the terminal size
+ * is unknown.
+ */
+function fitsOnScreen(output) {
+  const {
+    rows,
+    columns
+  } = process.stdout;
+  if (!rows || !columns) return false;
+  // split at most rows+1 lines — enough to prove overflow — so the array never scales with the
+  // full (potentially huge) output; the loop below also early-exits once one screen is exceeded.
+  const lines = output.replace(/\n$/, '').split('\n', rows + 1);
+  let usedRows = 0;
+  for (const line of lines) {
+    const width = ((0, _legacy2().removeChalkCharacters)(line) || '').length;
+    usedRows += width === 0 ? 1 : Math.ceil(width / columns);
+    if (usedRows > rows) return false; // stop early once we know it overflows one screen
+  }
+  return true;
+}
+
+/**
+ * decide whether a command's report output should be piped through a pager.
+ * mirrors git: on by default for interactive terminals, off for anything else. explicit flags
+ * (--pager / --no-pager) and the BIT_NO_PAGER env var override the automatic behavior. in the
+ * automatic case, output that already fits on the screen is printed directly (no pager).
+ */
+function shouldUsePager(command, flags, output) {
+  if (!command.pager) return false; // command didn't opt-in to paging
+  if (flags.json) return false; // json is for machine consumption, never page it
+  // explicit CLI flags win over the BIT_NO_PAGER env var, so `--pager` can force paging for a
+  // single invocation even when the user exports BIT_NO_PAGER globally.
+  if (flags['no-pager']) return false;
+  if (flags.pager) return true; // explicit force-on, even when non-interactive / fits on screen
+  if (isEnvSet('BIT_NO_PAGER')) return false; // env opt-out (overridable by --pager above)
+  if (!isInteractiveTerminal()) return false;
+  return !fitsOnScreen(output); // only page when the output is longer than one screen
+}
+
+/**
+ * split a configured pager string (BIT_PAGER / PAGER) into [command, ...args], honoring single and
+ * double quotes so an executable path that contains spaces can be configured, e.g.
+ * `"/Applications/My Pager/less" -R`. we deliberately don't run the pager through a shell (avoids
+ * shell-injection and the ENOENT-swallows-output problem), so quoting is how a spaced path is
+ * expressed.
+ */
+function parsePagerCommand(pager) {
+  const tokens = pager.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+  return tokens.map(token => token.replace(/^["']|["']$/g, ''));
+}
+
+/**
+ * pipe the given output through a pager (`less` by default). resolves to `true` only after the
+ * pager process has exited cleanly — the caller must await this before exiting the process so the
+ * pager isn't cut off. resolves to `false` when paging is disabled, the pager couldn't launch, or
+ * it exited with an error, in which case the caller must write the data directly so nothing is lost.
+ *
+ * the pager binary is taken from BIT_PAGER, then PAGER, defaulting to `less`. an empty or `cat`
+ * pager means the user disabled paging via the env — honored unless `force` is set (the `--pager`
+ * flag), which falls back to a real pager so the flag is a true override. for `less` we set
+ * `LESS=FRX` (unless already set, matching git's default): keep ansi colors (-R), don't clear the
+ * screen on exit (-X), and quit if the output fits one screen (-F).
+ */
+function writeToPager(data, force = false) {
+  return new Promise(resolve => {
+    // BIT_PAGER wins over PAGER; default to `less` only when neither is set. use `??` (not `||`)
+    // so an explicit empty string is preserved rather than treated as unset — that lets
+    // BIT_PAGER="" disable paging.
+    const configuredPager = process.env.BIT_PAGER ?? process.env.PAGER ?? 'less';
+    const tokens = parsePagerCommand(configuredPager);
+    // an empty / "cat" pager means the user disabled paging. honor that, unless `--pager` forces
+    // paging on, in which case fall back to a real pager so the flag is a true override.
+    const disabled = !tokens[0] || tokens[0] === 'cat';
+    if (disabled && !force) {
+      resolve(false);
+      return;
+    }
+    const [cmd, ...args] = disabled ? ['less'] : tokens;
+    const env = _objectSpread({}, process.env);
+    // LESS=FRX only makes sense for `less` itself; don't leak it into other pagers or wrapper scripts.
+    if (/^less(\.exe)?$/i.test((0, _path().basename)(cmd)) && !env.LESS) env.LESS = 'FRX';
+    try {
+      const child = (0, _child_process().spawn)(cmd, args, {
+        stdio: ['pipe', 'inherit', 'inherit'],
+        env
+      });
+      // pager missing (ENOENT) or otherwise failed to launch => fall back to a direct write.
+      child.on('error', () => resolve(false));
+      // resolve success only on a clean exit (code 0) or a signal (code null, e.g. the user killed
+      // it). a non-zero exit means the pager failed (bad args, couldn't render) without showing the
+      // output, so fall back to a direct write and never lose it.
+      child.on('close', code => resolve(code === 0 || code === null));
+      // ignore EPIPE that happens when the user quits the pager (e.g. "q") before all data is read.
+      child.stdin?.on('error', () => {});
+      child.stdin?.write(data);
+      child.stdin?.end();
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+//# sourceMappingURL=pager.js.map