@automatify-au/cli 0.1.2 → 0.1.3

package/dist/automatify.js

@@ -1,4 +1,983 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/buffer-crc32@1.0.0/node_modules/buffer-crc32/dist/index.cjs
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/buffer-crc32@1.0.0/node_modules/buffer-crc32/dist/index.cjs"(exports, module) {
+    "use strict";
+    function getDefaultExportFromCjs(x) {
+      return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+    }
+    var CRC_TABLE = new Int32Array([
+      0,
+      1996959894,
+      3993919788,
+      2567524794,
+      124634137,
+      1886057615,
+      3915621685,
+      2657392035,
+      249268274,
+      2044508324,
+      3772115230,
+      2547177864,
+      162941995,
+      2125561021,
+      3887607047,
+      2428444049,
+      498536548,
+      1789927666,
+      4089016648,
+      2227061214,
+      450548861,
+      1843258603,
+      4107580753,
+      2211677639,
+      325883990,
+      1684777152,
+      4251122042,
+      2321926636,
+      335633487,
+      1661365465,
+      4195302755,
+      2366115317,
+      997073096,
+      1281953886,
+      3579855332,
+      2724688242,
+      1006888145,
+      1258607687,
+      3524101629,
+      2768942443,
+      901097722,
+      1119000684,
+      3686517206,
+      2898065728,
+      853044451,
+      1172266101,
+      3705015759,
+      2882616665,
+      651767980,
+      1373503546,
+      3369554304,
+      3218104598,
+      565507253,
+      1454621731,
+      3485111705,
+      3099436303,
+      671266974,
+      1594198024,
+      3322730930,
+      2970347812,
+      795835527,
+      1483230225,
+      3244367275,
+      3060149565,
+      1994146192,
+      31158534,
+      2563907772,
+      4023717930,
+      1907459465,
+      112637215,
+      2680153253,
+      3904427059,
+      2013776290,
+      251722036,
+      2517215374,
+      3775830040,
+      2137656763,
+      141376813,
+      2439277719,
+      3865271297,
+      1802195444,
+      476864866,
+      2238001368,
+      4066508878,
+      1812370925,
+      453092731,
+      2181625025,
+      4111451223,
+      1706088902,
+      314042704,
+      2344532202,
+      4240017532,
+      1658658271,
+      366619977,
+      2362670323,
+      4224994405,
+      1303535960,
+      984961486,
+      2747007092,
+      3569037538,
+      1256170817,
+      1037604311,
+      2765210733,
+      3554079995,
+      1131014506,
+      879679996,
+      2909243462,
+      3663771856,
+      1141124467,
+      855842277,
+      2852801631,
+      3708648649,
+      1342533948,
+      654459306,
+      3188396048,
+      3373015174,
+      1466479909,
+      544179635,
+      3110523913,
+      3462522015,
+      1591671054,
+      702138776,
+      2966460450,
+      3352799412,
+      1504918807,
+      783551873,
+      3082640443,
+      3233442989,
+      3988292384,
+      2596254646,
+      62317068,
+      1957810842,
+      3939845945,
+      2647816111,
+      81470997,
+      1943803523,
+      3814918930,
+      2489596804,
+      225274430,
+      2053790376,
+      3826175755,
+      2466906013,
+      167816743,
+      2097651377,
+      4027552580,
+      2265490386,
+      503444072,
+      1762050814,
+      4150417245,
+      2154129355,
+      426522225,
+      1852507879,
+      4275313526,
+      2312317920,
+      282753626,
+      1742555852,
+      4189708143,
+      2394877945,
+      397917763,
+      1622183637,
+      3604390888,
+      2714866558,
+      953729732,
+      1340076626,
+      3518719985,
+      2797360999,
+      1068828381,
+      1219638859,
+      3624741850,
+      2936675148,
+      906185462,
+      1090812512,
+      3747672003,
+      2825379669,
+      829329135,
+      1181335161,
+      3412177804,
+      3160834842,
+      628085408,
+      1382605366,
+      3423369109,
+      3138078467,
+      570562233,
+      1426400815,
+      3317316542,
+      2998733608,
+      733239954,
+      1555261956,
+      3268935591,
+      3050360625,
+      752459403,
+      1541320221,
+      2607071920,
+      3965973030,
+      1969922972,
+      40735498,
+      2617837225,
+      3943577151,
+      1913087877,
+      83908371,
+      2512341634,
+      3803740692,
+      2075208622,
+      213261112,
+      2463272603,
+      3855990285,
+      2094854071,
+      198958881,
+      2262029012,
+      4057260610,
+      1759359992,
+      534414190,
+      2176718541,
+      4139329115,
+      1873836001,
+      414664567,
+      2282248934,
+      4279200368,
+      1711684554,
+      285281116,
+      2405801727,
+      4167216745,
+      1634467795,
+      376229701,
+      2685067896,
+      3608007406,
+      1308918612,
+      956543938,
+      2808555105,
+      3495958263,
+      1231636301,
+      1047427035,
+      2932959818,
+      3654703836,
+      1088359270,
+      936918e3,
+      2847714899,
+      3736837829,
+      1202900863,
+      817233897,
+      3183342108,
+      3401237130,
+      1404277552,
+      615818150,
+      3134207493,
+      3453421203,
+      1423857449,
+      601450431,
+      3009837614,
+      3294710456,
+      1567103746,
+      711928724,
+      3020668471,
+      3272380065,
+      1510334235,
+      755167117
+    ]);
+    function ensureBuffer(input) {
+      if (Buffer.isBuffer(input)) {
+        return input;
+      }
+      if (typeof input === "number") {
+        return Buffer.alloc(input);
+      } else if (typeof input === "string") {
+        return Buffer.from(input);
+      } else {
+        throw new Error("input must be buffer, number, or string, received " + typeof input);
+      }
+    }
+    function bufferizeInt(num) {
+      const tmp = ensureBuffer(4);
+      tmp.writeInt32BE(num, 0);
+      return tmp;
+    }
+    function _crc32(buf, previous) {
+      buf = ensureBuffer(buf);
+      if (Buffer.isBuffer(previous)) {
+        previous = previous.readUInt32BE(0);
+      }
+      let crc = ~~previous ^ -1;
+      for (var n = 0; n < buf.length; n++) {
+        crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
+      }
+      return crc ^ -1;
+    }
+    function crc32() {
+      return bufferizeInt(_crc32.apply(null, arguments));
+    }
+    crc32.signed = function() {
+      return _crc32.apply(null, arguments);
+    };
+    crc32.unsigned = function() {
+      return _crc32.apply(null, arguments) >>> 0;
+    };
+    var bufferCrc32 = crc32;
+    var index = /* @__PURE__ */ getDefaultExportFromCjs(bufferCrc32);
+    module.exports = index;
+  }
+});
+
+// ../../node_modules/.pnpm/yazl@3.3.1/node_modules/yazl/index.js
+var require_yazl = __commonJS({
+  "../../node_modules/.pnpm/yazl@3.3.1/node_modules/yazl/index.js"(exports) {
+    var fs = __require("fs");
+    var Transform = __require("stream").Transform;
+    var PassThrough = __require("stream").PassThrough;
+    var zlib = __require("zlib");
+    var util = __require("util");
+    var EventEmitter = __require("events").EventEmitter;
+    var errorMonitor = __require("events").errorMonitor;
+    var crc32 = require_dist();
+    exports.ZipFile = ZipFile2;
+    exports.dateToDosDateTime = dateToDosDateTime;
+    util.inherits(ZipFile2, EventEmitter);
+    function ZipFile2() {
+      this.outputStream = new PassThrough();
+      this.entries = [];
+      this.outputStreamCursor = 0;
+      this.ended = false;
+      this.allDone = false;
+      this.forceZip64Eocd = false;
+      this.errored = false;
+      this.on(errorMonitor, function() {
+        this.errored = true;
+      });
+    }
+    ZipFile2.prototype.addFile = function(realPath, metadataPath, options) {
+      var self = this;
+      metadataPath = validateMetadataPath(metadataPath, false);
+      if (options == null) options = {};
+      if (shouldIgnoreAdding(self)) return;
+      var entry = new Entry(metadataPath, false, options);
+      self.entries.push(entry);
+      fs.stat(realPath, function(err, stats) {
+        if (err) return self.emit("error", err);
+        if (!stats.isFile()) return self.emit("error", new Error("not a file: " + realPath));
+        entry.uncompressedSize = stats.size;
+        if (options.mtime == null) entry.setLastModDate(stats.mtime);
+        if (options.mode == null) entry.setFileAttributesMode(stats.mode);
+        entry.setFileDataPumpFunction(function() {
+          var readStream = fs.createReadStream(realPath);
+          entry.state = Entry.FILE_DATA_IN_PROGRESS;
+          readStream.on("error", function(err2) {
+            self.emit("error", err2);
+          });
+          pumpFileDataReadStream(self, entry, readStream);
+        });
+        pumpEntries(self);
+      });
+    };
+    ZipFile2.prototype.addReadStream = function(readStream, metadataPath, options) {
+      this.addReadStreamLazy(metadataPath, options, function(cb) {
+        cb(null, readStream);
+      });
+    };
+    ZipFile2.prototype.addReadStreamLazy = function(metadataPath, options, getReadStreamFunction) {
+      var self = this;
+      if (typeof options === "function") {
+        getReadStreamFunction = options;
+        options = null;
+      }
+      if (options == null) options = {};
+      metadataPath = validateMetadataPath(metadataPath, false);
+      if (shouldIgnoreAdding(self)) return;
+      var entry = new Entry(metadataPath, false, options);
+      self.entries.push(entry);
+      entry.setFileDataPumpFunction(function() {
+        entry.state = Entry.FILE_DATA_IN_PROGRESS;
+        getReadStreamFunction(function(err, readStream) {
+          if (err) return self.emit("error", err);
+          pumpFileDataReadStream(self, entry, readStream);
+        });
+      });
+      pumpEntries(self);
+    };
+    ZipFile2.prototype.addBuffer = function(buffer, metadataPath, options) {
+      var self = this;
+      metadataPath = validateMetadataPath(metadataPath, false);
+      if (buffer.length > 1073741823) throw new Error("buffer too large: " + buffer.length + " > 1073741823");
+      if (options == null) options = {};
+      if (options.size != null) throw new Error("options.size not allowed");
+      if (shouldIgnoreAdding(self)) return;
+      var entry = new Entry(metadataPath, false, options);
+      entry.uncompressedSize = buffer.length;
+      entry.crc32 = crc32.unsigned(buffer);
+      entry.crcAndFileSizeKnown = true;
+      self.entries.push(entry);
+      if (entry.compressionLevel === 0) {
+        setCompressedBuffer(buffer);
+      } else {
+        zlib.deflateRaw(buffer, { level: entry.compressionLevel }, function(err, compressedBuffer) {
+          setCompressedBuffer(compressedBuffer);
+        });
+      }
+      function setCompressedBuffer(compressedBuffer) {
+        entry.compressedSize = compressedBuffer.length;
+        entry.setFileDataPumpFunction(function() {
+          writeToOutputStream(self, compressedBuffer);
+          writeToOutputStream(self, entry.getDataDescriptor());
+          entry.state = Entry.FILE_DATA_DONE;
+          setImmediate(function() {
+            pumpEntries(self);
+          });
+        });
+        pumpEntries(self);
+      }
+    };
+    ZipFile2.prototype.addEmptyDirectory = function(metadataPath, options) {
+      var self = this;
+      metadataPath = validateMetadataPath(metadataPath, true);
+      if (options == null) options = {};
+      if (options.size != null) throw new Error("options.size not allowed");
+      if (options.compress != null) throw new Error("options.compress not allowed");
+      if (options.compressionLevel != null) throw new Error("options.compressionLevel not allowed");
+      if (shouldIgnoreAdding(self)) return;
+      var entry = new Entry(metadataPath, true, options);
+      self.entries.push(entry);
+      entry.setFileDataPumpFunction(function() {
+        writeToOutputStream(self, entry.getDataDescriptor());
+        entry.state = Entry.FILE_DATA_DONE;
+        pumpEntries(self);
+      });
+      pumpEntries(self);
+    };
+    var eocdrSignatureBuffer = bufferFrom([80, 75, 5, 6]);
+    ZipFile2.prototype.end = function(options, calculatedTotalSizeCallback) {
+      if (typeof options === "function") {
+        calculatedTotalSizeCallback = options;
+        options = null;
+      }
+      if (options == null) options = {};
+      if (this.ended) return;
+      this.ended = true;
+      if (this.errored) return;
+      this.calculatedTotalSizeCallback = calculatedTotalSizeCallback;
+      this.forceZip64Eocd = !!options.forceZip64Format;
+      if (options.comment) {
+        if (typeof options.comment === "string") {
+          this.comment = encodeCp437(options.comment);
+        } else {
+          this.comment = options.comment;
+        }
+        if (this.comment.length > 65535) throw new Error("comment is too large");
+        if (bufferIncludes(this.comment, eocdrSignatureBuffer)) throw new Error("comment contains end of central directory record signature");
+      } else {
+        this.comment = EMPTY_BUFFER;
+      }
+      pumpEntries(this);
+    };
+    function writeToOutputStream(self, buffer) {
+      self.outputStream.write(buffer);
+      self.outputStreamCursor += buffer.length;
+    }
+    function pumpFileDataReadStream(self, entry, readStream) {
+      var crc32Watcher = new Crc32Watcher();
+      var uncompressedSizeCounter = new ByteCounter();
+      var compressor = entry.compressionLevel !== 0 ? new zlib.DeflateRaw({ level: entry.compressionLevel }) : new PassThrough();
+      var compressedSizeCounter = new ByteCounter();
+      readStream.pipe(crc32Watcher).pipe(uncompressedSizeCounter).pipe(compressor).pipe(compressedSizeCounter).pipe(self.outputStream, { end: false });
+      compressedSizeCounter.on("end", function() {
+        entry.crc32 = crc32Watcher.crc32;
+        if (entry.uncompressedSize == null) {
+          entry.uncompressedSize = uncompressedSizeCounter.byteCount;
+        } else {
+          if (entry.uncompressedSize !== uncompressedSizeCounter.byteCount) return self.emit("error", new Error("file data stream has unexpected number of bytes"));
+        }
+        entry.compressedSize = compressedSizeCounter.byteCount;
+        self.outputStreamCursor += entry.compressedSize;
+        writeToOutputStream(self, entry.getDataDescriptor());
+        entry.state = Entry.FILE_DATA_DONE;
+        pumpEntries(self);
+      });
+    }
+    function determineCompressionLevel(options) {
+      if (options.compress != null && options.compressionLevel != null) {
+        if (!!options.compress !== !!options.compressionLevel) throw new Error("conflicting settings for compress and compressionLevel");
+      }
+      if (options.compressionLevel != null) return options.compressionLevel;
+      if (options.compress === false) return 0;
+      return 6;
+    }
+    function pumpEntries(self) {
+      if (self.allDone || self.errored) return;
+      if (self.ended && self.calculatedTotalSizeCallback != null) {
+        var calculatedTotalSize = calculateTotalSize(self);
+        if (calculatedTotalSize != null) {
+          self.calculatedTotalSizeCallback(calculatedTotalSize);
+          self.calculatedTotalSizeCallback = null;
+        }
+      }
+      var entry = getFirstNotDoneEntry();
+      function getFirstNotDoneEntry() {
+        for (var i = 0; i < self.entries.length; i++) {
+          var entry2 = self.entries[i];
+          if (entry2.state < Entry.FILE_DATA_DONE) return entry2;
+        }
+        return null;
+      }
+      if (entry != null) {
+        if (entry.state < Entry.READY_TO_PUMP_FILE_DATA) return;
+        if (entry.state === Entry.FILE_DATA_IN_PROGRESS) return;
+        entry.relativeOffsetOfLocalHeader = self.outputStreamCursor;
+        var localFileHeader = entry.getLocalFileHeader();
+        writeToOutputStream(self, localFileHeader);
+        entry.doFileDataPump();
+      } else {
+        if (self.ended) {
+          self.offsetOfStartOfCentralDirectory = self.outputStreamCursor;
+          self.entries.forEach(function(entry2) {
+            var centralDirectoryRecord = entry2.getCentralDirectoryRecord();
+            writeToOutputStream(self, centralDirectoryRecord);
+          });
+          writeToOutputStream(self, getEndOfCentralDirectoryRecord(self));
+          self.outputStream.end();
+          self.allDone = true;
+        }
+      }
+    }
+    function calculateTotalSize(self) {
+      var pretendOutputCursor = 0;
+      var centralDirectorySize = 0;
+      for (var i = 0; i < self.entries.length; i++) {
+        var entry = self.entries[i];
+        if (entry.compressionLevel !== 0) return -1;
+        if (entry.state >= Entry.READY_TO_PUMP_FILE_DATA) {
+          if (entry.uncompressedSize == null) return -1;
+        } else {
+          if (entry.uncompressedSize == null) return null;
+        }
+        entry.relativeOffsetOfLocalHeader = pretendOutputCursor;
+        var useZip64Format = entry.useZip64Format();
+        pretendOutputCursor += LOCAL_FILE_HEADER_FIXED_SIZE + entry.utf8FileName.length;
+        pretendOutputCursor += entry.uncompressedSize;
+        if (!entry.crcAndFileSizeKnown) {
+          if (useZip64Format) {
+            pretendOutputCursor += ZIP64_DATA_DESCRIPTOR_SIZE;
+          } else {
+            pretendOutputCursor += DATA_DESCRIPTOR_SIZE;
+          }
+        }
+        centralDirectorySize += CENTRAL_DIRECTORY_RECORD_FIXED_SIZE + entry.utf8FileName.length + entry.fileComment.length;
+        if (!entry.forceDosTimestamp) {
+          centralDirectorySize += INFO_ZIP_UNIVERSAL_TIMESTAMP_EXTRA_FIELD_SIZE;
+        }
+        if (useZip64Format) {
+          centralDirectorySize += ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE;
+        }
+      }
+      var endOfCentralDirectorySize = 0;
+      if (self.forceZip64Eocd || self.entries.length >= 65535 || centralDirectorySize >= 65535 || pretendOutputCursor >= 4294967295) {
+        endOfCentralDirectorySize += ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE;
+      }
+      endOfCentralDirectorySize += END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self.comment.length;
+      return pretendOutputCursor + centralDirectorySize + endOfCentralDirectorySize;
+    }
+    function shouldIgnoreAdding(self) {
+      if (self.ended) throw new Error("cannot add entries after calling end()");
+      if (self.errored) return true;
+      return false;
+    }
+    var ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 56;
+    var ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE = 20;
+    var END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 22;
+    function getEndOfCentralDirectoryRecord(self, actuallyJustTellMeHowLongItWouldBe) {
+      var needZip64Format = false;
+      var normalEntriesLength = self.entries.length;
+      if (self.forceZip64Eocd || self.entries.length >= 65535) {
+        normalEntriesLength = 65535;
+        needZip64Format = true;
+      }
+      var sizeOfCentralDirectory = self.outputStreamCursor - self.offsetOfStartOfCentralDirectory;
+      var normalSizeOfCentralDirectory = sizeOfCentralDirectory;
+      if (self.forceZip64Eocd || sizeOfCentralDirectory >= 4294967295) {
+        normalSizeOfCentralDirectory = 4294967295;
+        needZip64Format = true;
+      }
+      var normalOffsetOfStartOfCentralDirectory = self.offsetOfStartOfCentralDirectory;
+      if (self.forceZip64Eocd || self.offsetOfStartOfCentralDirectory >= 4294967295) {
+        normalOffsetOfStartOfCentralDirectory = 4294967295;
+        needZip64Format = true;
+      }
+      if (actuallyJustTellMeHowLongItWouldBe) {
+        if (needZip64Format) {
+          return ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE + END_OF_CENTRAL_DIRECTORY_RECORD_SIZE;
+        } else {
+          return END_OF_CENTRAL_DIRECTORY_RECORD_SIZE;
+        }
+      }
+      var eocdrBuffer = bufferAlloc(END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self.comment.length);
+      eocdrBuffer.writeUInt32LE(101010256, 0);
+      eocdrBuffer.writeUInt16LE(0, 4);
+      eocdrBuffer.writeUInt16LE(0, 6);
+      eocdrBuffer.writeUInt16LE(normalEntriesLength, 8);
+      eocdrBuffer.writeUInt16LE(normalEntriesLength, 10);
+      eocdrBuffer.writeUInt32LE(normalSizeOfCentralDirectory, 12);
+      eocdrBuffer.writeUInt32LE(normalOffsetOfStartOfCentralDirectory, 16);
+      eocdrBuffer.writeUInt16LE(self.comment.length, 20);
+      self.comment.copy(eocdrBuffer, 22);
+      if (!needZip64Format) return eocdrBuffer;
+      var zip64EocdrBuffer = bufferAlloc(ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE);
+      zip64EocdrBuffer.writeUInt32LE(101075792, 0);
+      writeUInt64LE(zip64EocdrBuffer, ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE - 12, 4);
+      zip64EocdrBuffer.writeUInt16LE(VERSION_MADE_BY, 12);
+      zip64EocdrBuffer.writeUInt16LE(VERSION_NEEDED_TO_EXTRACT_ZIP64, 14);
+      zip64EocdrBuffer.writeUInt32LE(0, 16);
+      zip64EocdrBuffer.writeUInt32LE(0, 20);
+      writeUInt64LE(zip64EocdrBuffer, self.entries.length, 24);
+      writeUInt64LE(zip64EocdrBuffer, self.entries.length, 32);
+      writeUInt64LE(zip64EocdrBuffer, sizeOfCentralDirectory, 40);
+      writeUInt64LE(zip64EocdrBuffer, self.offsetOfStartOfCentralDirectory, 48);
+      var zip64EocdlBuffer = bufferAlloc(ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE);
+      zip64EocdlBuffer.writeUInt32LE(117853008, 0);
+      zip64EocdlBuffer.writeUInt32LE(0, 4);
+      writeUInt64LE(zip64EocdlBuffer, self.outputStreamCursor, 8);
+      zip64EocdlBuffer.writeUInt32LE(1, 16);
+      return Buffer.concat([
+        zip64EocdrBuffer,
+        zip64EocdlBuffer,
+        eocdrBuffer
+      ]);
+    }
+    function validateMetadataPath(metadataPath, isDirectory) {
+      if (metadataPath === "") throw new Error("empty metadataPath");
+      metadataPath = metadataPath.replace(/\\/g, "/");
+      if (/^[a-zA-Z]:/.test(metadataPath) || /^\//.test(metadataPath)) throw new Error("absolute path: " + metadataPath);
+      if (metadataPath.split("/").indexOf("..") !== -1) throw new Error("invalid relative path: " + metadataPath);
+      var looksLikeDirectory = /\/$/.test(metadataPath);
+      if (isDirectory) {
+        if (!looksLikeDirectory) metadataPath += "/";
+      } else {
+        if (looksLikeDirectory) throw new Error("file path cannot end with '/': " + metadataPath);
+      }
+      return metadataPath;
+    }
+    var EMPTY_BUFFER = bufferAlloc(0);
+    function Entry(metadataPath, isDirectory, options) {
+      this.utf8FileName = bufferFrom(metadataPath);
+      if (this.utf8FileName.length > 65535) throw new Error("utf8 file name too long. " + utf8FileName.length + " > 65535");
+      this.isDirectory = isDirectory;
+      this.state = Entry.WAITING_FOR_METADATA;
+      this.setLastModDate(options.mtime != null ? options.mtime : /* @__PURE__ */ new Date());
+      this.forceDosTimestamp = !!options.forceDosTimestamp;
+      if (options.mode != null) {
+        this.setFileAttributesMode(options.mode);
+      } else {
+        this.setFileAttributesMode(isDirectory ? 16893 : 33204);
+      }
+      if (isDirectory) {
+        this.crcAndFileSizeKnown = true;
+        this.crc32 = 0;
+        this.uncompressedSize = 0;
+        this.compressedSize = 0;
+      } else {
+        this.crcAndFileSizeKnown = false;
+        this.crc32 = null;
+        this.uncompressedSize = null;
+        this.compressedSize = null;
+        if (options.size != null) this.uncompressedSize = options.size;
+      }
+      if (isDirectory) {
+        this.compressionLevel = 0;
+      } else {
+        this.compressionLevel = determineCompressionLevel(options);
+      }
+      this.forceZip64Format = !!options.forceZip64Format;
+      if (options.fileComment) {
+        if (typeof options.fileComment === "string") {
+          this.fileComment = bufferFrom(options.fileComment, "utf-8");
+        } else {
+          this.fileComment = options.fileComment;
+        }
+        if (this.fileComment.length > 65535) throw new Error("fileComment is too large");
+      } else {
+        this.fileComment = EMPTY_BUFFER;
+      }
+    }
+    Entry.WAITING_FOR_METADATA = 0;
+    Entry.READY_TO_PUMP_FILE_DATA = 1;
+    Entry.FILE_DATA_IN_PROGRESS = 2;
+    Entry.FILE_DATA_DONE = 3;
+    Entry.prototype.setLastModDate = function(date) {
+      this.mtime = date;
+      var dosDateTime = dateToDosDateTime(date);
+      this.lastModFileTime = dosDateTime.time;
+      this.lastModFileDate = dosDateTime.date;
+    };
+    Entry.prototype.setFileAttributesMode = function(mode) {
+      if ((mode & 65535) !== mode) throw new Error("invalid mode. expected: 0 <= " + mode + " <= 65535");
+      this.externalFileAttributes = mode << 16 >>> 0;
+    };
+    Entry.prototype.setFileDataPumpFunction = function(doFileDataPump) {
+      this.doFileDataPump = doFileDataPump;
+      this.state = Entry.READY_TO_PUMP_FILE_DATA;
+    };
+    Entry.prototype.useZip64Format = function() {
+      return this.forceZip64Format || this.uncompressedSize != null && this.uncompressedSize > 4294967294 || this.compressedSize != null && this.compressedSize > 4294967294 || this.relativeOffsetOfLocalHeader != null && this.relativeOffsetOfLocalHeader > 4294967294;
+    };
+    var LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+    var VERSION_NEEDED_TO_EXTRACT_UTF8 = 20;
+    var VERSION_NEEDED_TO_EXTRACT_ZIP64 = 45;
+    var VERSION_MADE_BY = 3 << 8 | 63;
+    var FILE_NAME_IS_UTF8 = 1 << 11;
+    var UNKNOWN_CRC32_AND_FILE_SIZES = 1 << 3;
+    Entry.prototype.getLocalFileHeader = function() {
+      var crc322 = 0;
+      var compressedSize = 0;
+      var uncompressedSize = 0;
+      if (this.crcAndFileSizeKnown) {
+        crc322 = this.crc32;
+        compressedSize = this.compressedSize;
+        uncompressedSize = this.uncompressedSize;
+      }
+      var fixedSizeStuff = bufferAlloc(LOCAL_FILE_HEADER_FIXED_SIZE);
+      var generalPurposeBitFlag = FILE_NAME_IS_UTF8;
+      if (!this.crcAndFileSizeKnown) generalPurposeBitFlag |= UNKNOWN_CRC32_AND_FILE_SIZES;
+      fixedSizeStuff.writeUInt32LE(67324752, 0);
+      fixedSizeStuff.writeUInt16LE(VERSION_NEEDED_TO_EXTRACT_UTF8, 4);
+      fixedSizeStuff.writeUInt16LE(generalPurposeBitFlag, 6);
+      fixedSizeStuff.writeUInt16LE(this.getCompressionMethod(), 8);
+      fixedSizeStuff.writeUInt16LE(this.lastModFileTime, 10);
+      fixedSizeStuff.writeUInt16LE(this.lastModFileDate, 12);
+      fixedSizeStuff.writeUInt32LE(crc322, 14);
+      fixedSizeStuff.writeUInt32LE(compressedSize, 18);
+      fixedSizeStuff.writeUInt32LE(uncompressedSize, 22);
+      fixedSizeStuff.writeUInt16LE(this.utf8FileName.length, 26);
+      fixedSizeStuff.writeUInt16LE(0, 28);
+      return Buffer.concat([
+        fixedSizeStuff,
+        // file name (variable size)
+        this.utf8FileName
+        // extra field (variable size)
+        // no extra fields
+      ]);
+    };
+    var DATA_DESCRIPTOR_SIZE = 16;
+    var ZIP64_DATA_DESCRIPTOR_SIZE = 24;
+    Entry.prototype.getDataDescriptor = function() {
+      if (this.crcAndFileSizeKnown) {
+        return EMPTY_BUFFER;
+      }
+      if (!this.useZip64Format()) {
+        var buffer = bufferAlloc(DATA_DESCRIPTOR_SIZE);
+        buffer.writeUInt32LE(134695760, 0);
+        buffer.writeUInt32LE(this.crc32, 4);
+        buffer.writeUInt32LE(this.compressedSize, 8);
+        buffer.writeUInt32LE(this.uncompressedSize, 12);
+        return buffer;
+      } else {
+        var buffer = bufferAlloc(ZIP64_DATA_DESCRIPTOR_SIZE);
+        buffer.writeUInt32LE(134695760, 0);
+        buffer.writeUInt32LE(this.crc32, 4);
+        writeUInt64LE(buffer, this.compressedSize, 8);
+        writeUInt64LE(buffer, this.uncompressedSize, 16);
+        return buffer;
+      }
+    };
+    var CENTRAL_DIRECTORY_RECORD_FIXED_SIZE = 46;
+    var INFO_ZIP_UNIVERSAL_TIMESTAMP_EXTRA_FIELD_SIZE = 9;
+    var ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE = 28;
+    Entry.prototype.getCentralDirectoryRecord = function() {
+      var fixedSizeStuff = bufferAlloc(CENTRAL_DIRECTORY_RECORD_FIXED_SIZE);
+      var generalPurposeBitFlag = FILE_NAME_IS_UTF8;
+      if (!this.crcAndFileSizeKnown) generalPurposeBitFlag |= UNKNOWN_CRC32_AND_FILE_SIZES;
+      var izutefBuffer = EMPTY_BUFFER;
+      if (!this.forceDosTimestamp) {
+        izutefBuffer = bufferAlloc(INFO_ZIP_UNIVERSAL_TIMESTAMP_EXTRA_FIELD_SIZE);
+        izutefBuffer.writeUInt16LE(21589, 0);
+        izutefBuffer.writeUInt16LE(INFO_ZIP_UNIVERSAL_TIMESTAMP_EXTRA_FIELD_SIZE - 4, 2);
+        var EB_UT_FL_MTIME = 1 << 0;
+        var EB_UT_FL_ATIME = 1 << 1;
+        izutefBuffer.writeUInt8(EB_UT_FL_MTIME | EB_UT_FL_ATIME, 4);
+        var timestamp = Math.floor(this.mtime.getTime() / 1e3);
+        if (timestamp < -2147483648) timestamp = -2147483648;
+        if (timestamp > 2147483647) timestamp = 2147483647;
+        izutefBuffer.writeUInt32LE(timestamp, 5);
+      }
+      var normalCompressedSize = this.compressedSize;
+      var normalUncompressedSize = this.uncompressedSize;
+      var normalRelativeOffsetOfLocalHeader = this.relativeOffsetOfLocalHeader;
+      var versionNeededToExtract = VERSION_NEEDED_TO_EXTRACT_UTF8;
+      var zeiefBuffer = EMPTY_BUFFER;
+      if (this.useZip64Format()) {
+        normalCompressedSize = 4294967295;
+        normalUncompressedSize = 4294967295;
+        normalRelativeOffsetOfLocalHeader = 4294967295;
+        versionNeededToExtract = VERSION_NEEDED_TO_EXTRACT_ZIP64;
+        zeiefBuffer = bufferAlloc(ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE);
+        zeiefBuffer.writeUInt16LE(1, 0);
+        zeiefBuffer.writeUInt16LE(ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE - 4, 2);
+        writeUInt64LE(zeiefBuffer, this.uncompressedSize, 4);
+        writeUInt64LE(zeiefBuffer, this.compressedSize, 12);
+        writeUInt64LE(zeiefBuffer, this.relativeOffsetOfLocalHeader, 20);
+      }
+      fixedSizeStuff.writeUInt32LE(33639248, 0);
+      fixedSizeStuff.writeUInt16LE(VERSION_MADE_BY, 4);
+      fixedSizeStuff.writeUInt16LE(versionNeededToExtract, 6);
+      fixedSizeStuff.writeUInt16LE(generalPurposeBitFlag, 8);
+      fixedSizeStuff.writeUInt16LE(this.getCompressionMethod(), 10);
+      fixedSizeStuff.writeUInt16LE(this.lastModFileTime, 12);
+      fixedSizeStuff.writeUInt16LE(this.lastModFileDate, 14);
+      fixedSizeStuff.writeUInt32LE(this.crc32, 16);
+      fixedSizeStuff.writeUInt32LE(normalCompressedSize, 20);
+      fixedSizeStuff.writeUInt32LE(normalUncompressedSize, 24);
+      fixedSizeStuff.writeUInt16LE(this.utf8FileName.length, 28);
+      fixedSizeStuff.writeUInt16LE(izutefBuffer.length + zeiefBuffer.length, 30);
+      fixedSizeStuff.writeUInt16LE(this.fileComment.length, 32);
+      fixedSizeStuff.writeUInt16LE(0, 34);
+      fixedSizeStuff.writeUInt16LE(0, 36);
+      fixedSizeStuff.writeUInt32LE(this.externalFileAttributes, 38);
+      fixedSizeStuff.writeUInt32LE(normalRelativeOffsetOfLocalHeader, 42);
+      return Buffer.concat([
+        fixedSizeStuff,
+        // file name (variable size)
+        this.utf8FileName,
+        // extra field (variable size)
+        izutefBuffer,
+        zeiefBuffer,
+        // file comment (variable size)
+        this.fileComment
+      ]);
+    };
+    Entry.prototype.getCompressionMethod = function() {
+      var NO_COMPRESSION = 0;
+      var DEFLATE_COMPRESSION = 8;
+      return this.compressionLevel === 0 ? NO_COMPRESSION : DEFLATE_COMPRESSION;
+    };
+    var minDosDate = new Date(1980, 0, 1);
+    var maxDosDate = new Date(2107, 11, 31, 23, 59, 58);
+    function dateToDosDateTime(jsDate) {
+      if (jsDate < minDosDate) jsDate = minDosDate;
+      else if (jsDate > maxDosDate) jsDate = maxDosDate;
+      var date = 0;
+      date |= jsDate.getDate() & 31;
+      date |= (jsDate.getMonth() + 1 & 15) << 5;
+      date |= (jsDate.getFullYear() - 1980 & 127) << 9;
+      var time = 0;
+      time |= Math.floor(jsDate.getSeconds() / 2);
+      time |= (jsDate.getMinutes() & 63) << 5;
+      time |= (jsDate.getHours() & 31) << 11;
+      return { date, time };
+    }
+    function writeUInt64LE(buffer, n, offset) {
+      var high = Math.floor(n / 4294967296);
+      var low = n % 4294967296;
+      buffer.writeUInt32LE(low, offset);
+      buffer.writeUInt32LE(high, offset + 4);
+    }
+    util.inherits(ByteCounter, Transform);
+    function ByteCounter(options) {
+      Transform.call(this, options);
+      this.byteCount = 0;
+    }
+    ByteCounter.prototype._transform = function(chunk, encoding, cb) {
+      this.byteCount += chunk.length;
+      cb(null, chunk);
+    };
+    util.inherits(Crc32Watcher, Transform);
+    function Crc32Watcher(options) {
+      Transform.call(this, options);
+      this.crc32 = 0;
+    }
+    Crc32Watcher.prototype._transform = function(chunk, encoding, cb) {
+      this.crc32 = crc32.unsigned(chunk, this.crc32);
+      cb(null, chunk);
+    };
+    var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+    if (cp437.length !== 256) throw new Error("assertion failure");
+    var reverseCp437 = null;
+    function encodeCp437(string) {
+      if (/^[\x20-\x7e]*$/.test(string)) {
+        return bufferFrom(string, "utf-8");
+      }
+      if (reverseCp437 == null) {
+        reverseCp437 = {};
+        for (var i = 0; i < cp437.length; i++) {
+          reverseCp437[cp437[i]] = i;
+        }
+      }
+      var result = bufferAlloc(string.length);
+      for (var i = 0; i < string.length; i++) {
+        var b = reverseCp437[string[i]];
+        if (b == null) throw new Error("character not encodable in CP437: " + JSON.stringify(string[i]));
+        result[i] = b;
+      }
+      return result;
+    }
+    function bufferAlloc(size) {
+      bufferAlloc = modern;
+      try {
+        return bufferAlloc(size);
+      } catch (e) {
+        bufferAlloc = legacy;
+        return bufferAlloc(size);
+      }
+      function modern(size2) {
+        return Buffer.allocUnsafe(size2);
+      }
+      function legacy(size2) {
+        return new Buffer(size2);
+      }
+    }
+    function bufferFrom(something, encoding) {
+      bufferFrom = modern;
+      try {
+        return bufferFrom(something, encoding);
+      } catch (e) {
+        bufferFrom = legacy;
+        return bufferFrom(something, encoding);
+      }
+      function modern(something2, encoding2) {
+        return Buffer.from(something2, encoding2);
+      }
+      function legacy(something2, encoding2) {
+        return new Buffer(something2, encoding2);
+      }
+    }
+    function bufferIncludes(buffer, content) {
+      bufferIncludes = modern;
+      try {
+        return bufferIncludes(buffer, content);
+      } catch (e) {
+        bufferIncludes = legacy;
+        return bufferIncludes(buffer, content);
+      }
+      function modern(buffer2, content2) {
+        return buffer2.includes(content2);
+      }
+      function legacy(buffer2, content2) {
+        for (var i = 0; i <= buffer2.length - content2.length; i++) {
+          for (var j = 0; ; j++) {
+            if (j === content2.length) return true;
+            if (buffer2[i + j] !== content2[j]) break;
+          }
+        }
+        return false;
+      }
+    }
+  }
+});
 
 // src/cliResult.ts
 var ExitCode = {
@@ -1606,6 +2585,11 @@ function createAutoHandler(deps = {}) {
   };
 }
 
+// src/bdd.ts
+var import_yazl = __toESM(require_yazl(), 1);
+import { createWriteStream, mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync } from "node:fs";
+import path6 from "node:path";
+
 // src/forgeClient.ts
 var ForgeClientError = class extends Error {
   code;
@@ -1772,8 +2756,17 @@ function parseArgs2(args) {
   const flags = {};
   const boolFlags = /* @__PURE__ */ new Set();
   const unknownFlags = [];
-  const supportedValueFlags = /* @__PURE__ */ new Set(["--id", "--test-case-key", ...CONFIG_FLAGS2]);
-  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
+  const supportedValueFlags = /* @__PURE__ */ new Set([
+    "--id",
+    "--test-case-key",
+    "--format",
+    "--output-dir",
+    "--input-dir",
+    "--feature-id",
+    "--file",
+    ...CONFIG_FLAGS2
+  ]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json", "--zip", "--all"]);
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
     if (!token.startsWith("--")) {
@@ -1831,6 +2824,94 @@ function toJsonScenario(scenario) {
     updatedAt: scenario.updatedAt
   };
 }
+function scenarioToFeatureLines(scenario) {
+  const lines = [];
+  const tagSet = /* @__PURE__ */ new Set();
+  tagSet.add(`@testops-scenario-${sanitizeFileToken(scenario.key ?? scenario.id)}`);
+  for (const tag of scenario.tags) {
+    tagSet.add(tag);
+  }
+  for (const issueKey of scenario.linkedIssueKeys) {
+    tagSet.add(`@${issueKey}`);
+  }
+  if (tagSet.size > 0) {
+    lines.push([...tagSet].join(" "));
+  }
+  lines.push(`Feature: ${scenario.featureName}`);
+  lines.push("");
+  lines.push(`Scenario: ${scenario.name}`);
+  for (const step of scenario.steps) {
+    lines.push(`  ${step.keyword} ${step.text}`);
+  }
+  return lines;
+}
+function scenarioToExportFileName(scenario) {
+  return `${sanitizeFileToken(scenario.key ?? scenario.id)}.feature`;
+}
+var ISSUE_KEY_PATTERN = /^[A-Z][A-Z0-9]+-\d+$/;
+var SCENARIO_METADATA_PATTERN = /^@testops-scenario-([A-Za-z0-9._-]+)$/i;
+function parseScenarioFeatureFile(raw, filePath) {
+  let featureName = "";
+  let scenarioName = "";
+  let scenarioCount = 0;
+  const tags = [];
+  const steps = [];
+  let inScenario = false;
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    if (line.startsWith("@") && !inScenario && !scenarioName) {
+      tags.push(...line.split(/\s+/).filter(Boolean));
+      continue;
+    }
+    if (line.toLowerCase().startsWith("feature:")) {
+      featureName = line.slice("feature:".length).trim();
+      continue;
+    }
+    const scenarioMatch = line.match(/^Scenario(?: Outline)?:\s*(.+)$/i);
+    if (scenarioMatch) {
+      scenarioCount += 1;
+      if (scenarioCount > 1) {
+        return null;
+      }
+      scenarioName = scenarioMatch[1].trim();
+      inScenario = true;
+      continue;
+    }
+    const stepMatch = line.match(/^(Given|When|Then|And|But)\s+(.+)$/);
+    if (stepMatch) {
+      steps.push({
+        keyword: stepMatch[1],
+        text: stepMatch[2].trim()
+      });
+      continue;
+    }
+  }
+  const scenarioTag = tags.map((tag) => tag.match(SCENARIO_METADATA_PATTERN)).find((match) => Boolean(match));
+  const scenarioKeyFromTag = scenarioTag?.[1]?.trim().toUpperCase() ?? "";
+  const fileKeyMatch = path6.basename(filePath ?? "").match(/^(SC-\d+)\.feature$/i);
+  const scenarioKeyFromFile = fileKeyMatch?.[1]?.trim().toUpperCase() ?? "";
+  const scenarioKey = scenarioKeyFromTag || scenarioKeyFromFile;
+  if (scenarioKeyFromTag && scenarioKeyFromFile && scenarioKeyFromTag !== scenarioKeyFromFile) {
+    return null;
+  }
+  if (!featureName || !scenarioName || !scenarioKey || steps.length === 0 || scenarioCount !== 1) {
+    return null;
+  }
+  const linkedIssueKeys = [...new Set(
+    tags.map((tag) => tag.replace(/^@/, "").trim().toUpperCase()).filter((tag) => ISSUE_KEY_PATTERN.test(tag))
+  )];
+  return {
+    scenarioKey,
+    featureName,
+    scenarioName,
+    tags,
+    linkedIssueKeys,
+    steps
+  };
+}
 function scenarioToLines(scenario) {
   const lines = [
     `BDD scenario: ${scenario.name}`,
@@ -1847,6 +2928,64 @@ function scenarioToLines(scenario) {
   }
   return lines;
 }
+function featureToLines(feature) {
+  return [
+    `BDD feature: ${feature.payload.name}`,
+    `Feature id: ${feature.id}`,
+    `Project: ${feature.projectKey}`,
+    `Linked issues: ${feature.linkedIssueKeys.join(", ") || "none"}`,
+    `Created: ${feature.createdAt}`,
+    `Scenarios: ${feature.parsedSummary.scenarios}`,
+    `Steps: ${feature.parsedSummary.steps}`,
+    `Lines: ${feature.parsedSummary.lines}`
+  ];
+}
+function slugifyFeatureName(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "feature";
+}
+function sanitizeFileToken(value) {
+  return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "feature";
+}
+function buildFeatureExportFileName(feature, index) {
+  const slug = slugifyFeatureName(feature.payload.name);
+  const ordinal = String(index + 1).padStart(3, "0");
+  return `${ordinal}-${slug}.feature`;
+}
+function toExportManifestItems(features, fileNames) {
+  return features.map((feature, index) => ({
+    id: feature.id,
+    name: feature.payload.name,
+    fileName: fileNames[index],
+    linkedIssueKeys: [...feature.linkedIssueKeys],
+    scenarioCount: feature.parsedSummary.scenarios,
+    stepCount: feature.parsedSummary.steps,
+    createdAt: feature.createdAt
+  }));
+}
+function toJsonExportManifestItems(items) {
+  return items.map((item) => ({
+    id: item.id,
+    name: item.name,
+    fileName: item.fileName,
+    linkedIssueKeys: [...item.linkedIssueKeys],
+    scenarioCount: item.scenarioCount,
+    stepCount: item.stepCount,
+    createdAt: item.createdAt
+  }));
+}
+async function defaultCreateZipArchive(archivePath, entries) {
+  await new Promise((resolve, reject) => {
+    const zip = new import_yazl.ZipFile();
+    const output = zip.outputStream.pipe(createWriteStream(archivePath));
+    output.on("close", () => resolve());
+    output.on("error", reject);
+    zip.outputStream.on("error", reject);
+    for (const entry of entries) {
+      zip.addBuffer(Buffer.from(entry.content, "utf8"), entry.fileName);
+    }
+    zip.end();
+  });
+}
 function automationToLines(payload, scenarioKey) {
   return [
     `Triggered scenario automation for ${scenarioKey}`,
@@ -1867,10 +3006,16 @@ function missingProjectResponse() {
 function createBddHandler(deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
+  const mkdir = deps.mkdir ?? ((targetPath, options) => mkdirSync(targetPath, options));
+  const readFile = deps.readFile ?? ((filePath) => readFileSync4(filePath, "utf8"));
+  const readDir = deps.readDir ?? ((dirPath) => readdirSync2(dirPath));
+  const writeFile = deps.writeFile ?? ((filePath, content) => writeFileSync(filePath, content, "utf8"));
+  const createZipArchive = deps.createZipArchive ?? defaultCreateZipArchive;
   return async (request, context) => {
     const [subcommand, ...restArgs] = request.args;
     const parsed = parseArgs2(restArgs);
-    const useJson = parsed.boolFlags.has("--json");
+    const requestedFormat = (parsed.flags["--format"] ?? "").trim().toLowerCase();
+    const outputFormat = parsed.boolFlags.has("--json") ? "json" : requestedFormat || "text";
     const config = resolveCliConfig(pickConfigArgs2(parsed), env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
@@ -1880,20 +3025,373 @@ function createBddHandler(deps = {}) {
         stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
       };
     }
+    if (!["text", "json", "feature"].includes(outputFormat)) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Unsupported --format. Use one of: text, json, feature."]
+      };
+    }
     if (!projectKey) {
       return missingProjectResponse();
     }
+    if (subcommand === "features") {
+      const nested = restArgs[0];
+      if (nested !== "export") {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: [
+            "ERROR: Unsupported bdd features subcommand. Use: testops bdd features export --output-dir <path> [--feature-id <FEATURE_ID>] [--json]"
+          ]
+        };
+      }
+      const outputDirFlag = parsed.flags["--output-dir"]?.trim() ?? "";
+      const featureId = parsed.flags["--feature-id"]?.trim() ?? "";
+      const zipRequested = parsed.boolFlags.has("--zip");
+      if (!outputDirFlag) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: ["ERROR: Missing required --output-dir for testops bdd features export."]
+        };
+      }
+      const outputDir = path6.resolve(cwd, outputDirFlag);
+      try {
+        const result = await context.invokeForgeContract("listBddFeatures", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          }
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        const features = (featureId ? result.data.filter((feature) => feature.id === featureId) : result.data).sort((left, right) => left.payload.name.localeCompare(right.payload.name) || left.createdAt.localeCompare(right.createdAt));
+        if (featureId && features.length === 0) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: NOT_FOUND: BDD feature ${featureId} was not found in this project.`]
+          };
+        }
+        if (features.length === 0) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: ["ERROR: NOT_FOUND: No BDD features were found in this project context."]
+          };
+        }
+        mkdir(outputDir, { recursive: true });
+        const fileNames = features.map((feature, index) => buildFeatureExportFileName(feature, index));
+        const manifestItems = toExportManifestItems(features, fileNames);
+        const exportEntries = features.map((feature, index) => ({
+          fileName: fileNames[index],
+          content: `${feature.payload.gherkin.trimEnd()}
+`
+        }));
+        for (let index = 0; index < features.length; index += 1) {
+          writeFile(path6.join(outputDir, fileNames[index]), exportEntries[index].content);
+        }
+        const manifest = {
+          action: "bdd-features-export",
+          projectKey,
+          issueKey: issueKey || null,
+          outputDir,
+          exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          count: features.length,
+          items: manifestItems
+        };
+        const manifestContent = `${JSON.stringify(manifest, null, 2)}
+`;
+        writeFile(path6.join(outputDir, "manifest.json"), manifestContent);
+        const archivePath = `${outputDir}.zip`;
+        if (zipRequested) {
+          await createZipArchive(archivePath, [
+            ...exportEntries,
+            { fileName: "manifest.json", content: manifestContent }
+          ]);
+        }
+        if (outputFormat === "json") {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: manifest.action,
+              projectKey: manifest.projectKey,
+              issueKey: manifest.issueKey,
+              outputDir: manifest.outputDir,
+              exportedAt: manifest.exportedAt,
+              count: manifest.count,
+              items: toJsonExportManifestItems(manifestItems),
+              archivePath: zipRequested ? archivePath : null
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: [
+            `BDD features exported: ${features.length}`,
+            `Output directory: ${outputDir}`,
+            ...zipRequested ? [`ZIP archive: ${archivePath}`] : [],
+            "Files:",
+            ...manifestItems.flatMap((item) => [
+              `- ${item.fileName}`,
+              ...featureToLines(features.find((feature) => feature.id === item.id))
+            ])
+          ]
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError(error)}`]
+        };
+      }
+    }
     if (subcommand === "scenarios") {
       const nested = restArgs[0];
       if (nested !== "show") {
-        if (nested !== "run") {
+        if (nested !== "run" && nested !== "export" && nested !== "import") {
           return {
             exitCode: ExitCode.UsageError,
             stderr: [
-              "ERROR: Unsupported bdd scenarios subcommand. Use: testops bdd scenarios show --id <SCENARIO_ID> or testops bdd scenarios run --id <SCENARIO_ID> --test-case-key <TC-197>"
+              "ERROR: Unsupported bdd scenarios subcommand. Use: testops bdd scenarios show|run|export|import ..."
             ]
           };
         }
+        if (nested === "export") {
+          const scenarioSelector = parsed.flags["--id"]?.trim() ?? "";
+          const exportAll = parsed.boolFlags.has("--all");
+          const outputDirFlag = parsed.flags["--output-dir"]?.trim() ?? "";
+          if (!scenarioSelector && !exportAll) {
+            return {
+              exitCode: ExitCode.ValidationError,
+              stderr: ["ERROR: Provide --id <SCENARIO_ID|SC-4> or --all for testops bdd scenarios export."]
+            };
+          }
+          if (!outputDirFlag) {
+            return {
+              exitCode: ExitCode.ValidationError,
+              stderr: ["ERROR: Missing required --output-dir for testops bdd scenarios export."]
+            };
+          }
+          const outputDir = path6.resolve(cwd, outputDirFlag);
+          const zipRequested = parsed.boolFlags.has("--zip");
+          try {
+            const scenariosResult = await context.invokeForgeContract("listBddScenarios", {
+              context: {
+                projectKey,
+                issueKey: issueKey || void 0
+              }
+            });
+            if (!scenariosResult.ok) {
+              return {
+                exitCode: ExitCode.RemoteError,
+                stderr: [`ERROR: ${scenariosResult.error.code}: ${scenariosResult.error.message}`]
+              };
+            }
+            const selectedScenarios = exportAll ? [...scenariosResult.data].sort((left, right) => (left.key ?? left.id).localeCompare(right.key ?? right.id)) : scenariosResult.data.filter(
+              (item) => item.id === scenarioSelector || (item.key ?? "").toUpperCase() === scenarioSelector.toUpperCase()
+            );
+            if (!exportAll && selectedScenarios.length === 0) {
+              return {
+                exitCode: ExitCode.RemoteError,
+                stderr: [`ERROR: NOT_FOUND: BDD scenario ${scenarioSelector} was not found in this project.`]
+              };
+            }
+            if (selectedScenarios.length === 0) {
+              return {
+                exitCode: ExitCode.RemoteError,
+                stderr: ["ERROR: NOT_FOUND: No BDD scenarios were found in this project context."]
+              };
+            }
+            mkdir(outputDir, { recursive: true });
+            const items = selectedScenarios.map((scenario) => {
+              const fileName = scenarioToExportFileName(scenario);
+              const fileContent = `${scenarioToFeatureLines(scenario).join("\n")}
+`;
+              writeFile(path6.join(outputDir, fileName), fileContent);
+              return {
+                scenario,
+                fileName,
+                fileContent
+              };
+            });
+            const manifest = {
+              action: "bdd-scenarios-export",
+              projectKey,
+              issueKey: issueKey || null,
+              outputDir,
+              exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              count: items.length,
+              items: items.map(({ scenario, fileName }) => ({
+                id: scenario.id,
+                key: scenario.key ?? null,
+                featureName: scenario.featureName,
+                scenarioName: scenario.name,
+                fileName,
+                linkedIssueKeys: [...scenario.linkedIssueKeys],
+                tags: [...scenario.tags]
+              }))
+            };
+            const manifestContent = `${JSON.stringify(manifest, null, 2)}
+`;
+            writeFile(path6.join(outputDir, "manifest.json"), manifestContent);
+            const archivePath = `${outputDir}.zip`;
+            if (zipRequested) {
+              await createZipArchive(archivePath, [
+                ...items.map(({ fileName, fileContent }) => ({ fileName, content: fileContent })),
+                { fileName: "manifest.json", content: manifestContent }
+              ]);
+            }
+            if (outputFormat === "json") {
+              return {
+                exitCode: ExitCode.Success,
+                stdout: toJsonLine({
+                  action: manifest.action,
+                  projectKey,
+                  issueKey: issueKey || null,
+                  outputDir,
+                  exportedAt: manifest.exportedAt,
+                  count: items.length,
+                  archivePath: zipRequested ? archivePath : null,
+                  items: items.map(({ scenario, fileName }) => ({
+                    id: scenario.id,
+                    key: scenario.key ?? null,
+                    featureName: scenario.featureName,
+                    scenarioName: scenario.name,
+                    fileName,
+                    linkedIssueKeys: [...scenario.linkedIssueKeys],
+                    tags: [...scenario.tags]
+                  }))
+                })
+              };
+            }
+            return {
+              exitCode: ExitCode.Success,
+              stdout: [
+                `BDD scenarios exported: ${items.length}`,
+                `Output directory: ${outputDir}`,
+                ...zipRequested ? [`ZIP archive: ${archivePath}`] : [],
+                ...items.flatMap(({ scenario, fileName }) => [`File: ${fileName}`, ...scenarioToLines(scenario)])
+              ]
+            };
+          } catch (error) {
+            return {
+              exitCode: ExitCode.TransportError,
+              stderr: [`ERROR: ${normalizeError(error)}`]
+            };
+          }
+        }
+        if (nested === "import") {
+          const sourceFile = parsed.flags["--file"] ? path6.resolve(cwd, parsed.flags["--file"]) : "";
+          const inputDir = parsed.flags["--input-dir"] ? path6.resolve(cwd, parsed.flags["--input-dir"]) : "";
+          if (!sourceFile && !inputDir) {
+            return {
+              exitCode: ExitCode.ValidationError,
+              stderr: ["ERROR: Provide --file <SC-4.feature> or --input-dir <dir> for testops bdd scenarios import."]
+            };
+          }
+          try {
+            const scenarioFiles = sourceFile ? [sourceFile] : readDir(inputDir).filter((entry) => entry.toLowerCase().endsWith(".feature")).map((entry) => path6.join(inputDir, entry)).sort((left, right) => left.localeCompare(right));
+            if (scenarioFiles.length === 0) {
+              return {
+                exitCode: ExitCode.ValidationError,
+                stderr: ["ERROR: No .feature files were found for scenario import."]
+              };
+            }
+            const parsedScenarios = scenarioFiles.map((filePath) => ({
+              filePath,
+              parsed: parseScenarioFeatureFile(readFile(filePath), filePath)
+            }));
+            const invalidScenarioFile = parsedScenarios.find((item) => !item.parsed);
+            if (invalidScenarioFile) {
+              return {
+                exitCode: ExitCode.ValidationError,
+                stderr: [
+                  `ERROR: Scenario feature file ${invalidScenarioFile.filePath} must contain exactly one scenario, valid steps, and a matching SC-* key in tag or filename.`
+                ]
+              };
+            }
+            const scenariosResult = await context.invokeForgeContract("listBddScenarios", {
+              context: {
+                projectKey,
+                issueKey: issueKey || void 0
+              }
+            });
+            if (!scenariosResult.ok) {
+              return {
+                exitCode: ExitCode.RemoteError,
+                stderr: [`ERROR: ${scenariosResult.error.code}: ${scenariosResult.error.message}`]
+              };
+            }
+            const updatedItems = [];
+            for (const entry of parsedScenarios) {
+              const parsedScenario = entry.parsed;
+              const scenario = scenariosResult.data.find(
+                (item) => (item.key ?? "").toUpperCase() === parsedScenario.scenarioKey.toUpperCase()
+              );
+              if (!scenario) {
+                return {
+                  exitCode: ExitCode.RemoteError,
+                  stderr: [`ERROR: NOT_FOUND: BDD scenario ${parsedScenario.scenarioKey} was not found in this project.`]
+                };
+              }
+              const nextTags = parsedScenario.tags.filter((tag) => !SCENARIO_METADATA_PATTERN.test(tag));
+              const updateResult = await context.invokeForgeContract("updateScenario", {
+                context: {
+                  projectKey,
+                  issueKey: issueKey || void 0
+                },
+                scenarioId: scenario.id,
+                input: {
+                  featureName: parsedScenario.featureName,
+                  name: parsedScenario.scenarioName,
+                  steps: [...parsedScenario.steps],
+                  tags: nextTags,
+                  linkedIssueKeys: [...parsedScenario.linkedIssueKeys]
+                }
+              });
+              if (!updateResult.ok) {
+                return {
+                  exitCode: ExitCode.RemoteError,
+                  stderr: [`ERROR: ${updateResult.error.code}: ${updateResult.error.message}`]
+                };
+              }
+              updatedItems.push({
+                file: entry.filePath,
+                item: updateResult.data
+              });
+            }
+            if (outputFormat === "json") {
+              return {
+                exitCode: ExitCode.Success,
+                stdout: toJsonLine({
+                  action: "bdd-scenarios-import",
+                  projectKey,
+                  issueKey: issueKey || null,
+                  count: updatedItems.length,
+                  file: sourceFile || null,
+                  inputDir: inputDir || null,
+                  items: updatedItems.map((entry) => ({
+                    file: entry.file,
+                    item: toJsonScenario(entry.item)
+                  }))
+                })
+              };
+            }
+            return {
+              exitCode: ExitCode.Success,
+              stdout: updatedItems.flatMap((entry) => [
+                `BDD scenario imported: ${entry.item.key ?? entry.item.id}`,
+                `Source: ${entry.file}`,
+                ...scenarioToLines(entry.item)
+              ])
+            };
+          } catch (error) {
+            return {
+              exitCode: ExitCode.TransportError,
+              stderr: [`ERROR: ${normalizeError(error)}`]
+            };
+          }
+        }
         const scenarioId2 = parsed.flags["--id"]?.trim() ?? "";
         const testCaseKey = parsed.flags["--test-case-key"]?.trim().toUpperCase() ?? "";
         if (!scenarioId2 && !testCaseKey) {
@@ -1960,7 +3458,7 @@ function createBddHandler(deps = {}) {
             }
             runs.push(result.data);
           }
-          if (useJson) {
+          if (outputFormat === "json") {
             return {
               exitCode: ExitCode.Success,
               stdout: toJsonLine({
@@ -2018,7 +3516,7 @@ function createBddHandler(deps = {}) {
             stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
           };
         }
-        if (useJson) {
+        if (outputFormat === "json") {
           return {
             exitCode: ExitCode.Success,
             stdout: toJsonLine({
@@ -2029,6 +3527,12 @@ function createBddHandler(deps = {}) {
             })
           };
         }
+        if (outputFormat === "feature") {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: scenarioToFeatureLines(result.data)
+          };
+        }
         return {
           exitCode: ExitCode.Success,
           stdout: scenarioToLines(result.data)
@@ -2673,8 +4177,8 @@ function createDoctorHandler(deps = {}) {
 }
 
 // src/ingestFeature.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import path6 from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import path7 from "node:path";
 var CONFIG_FLAGS5 = /* @__PURE__ */ new Set([
   "--config",
   "--base-url",
@@ -2760,8 +4264,8 @@ function normalizeError3(error) {
   return "Unknown ingest error.";
 }
 function createIngestFeatureHandler(deps = {}) {
-  const readFile = deps.readFile ?? ((filePath) => readFileSync4(filePath, "utf8"));
-  const readStdin = deps.readStdin ?? (() => readFileSync4(0, "utf8"));
+  const readFile = deps.readFile ?? ((filePath) => readFileSync5(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => readFileSync5(0, "utf8"));
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
   return async (request, context) => {
@@ -2771,7 +4275,7 @@ function createIngestFeatureHandler(deps = {}) {
     const config = resolveCliConfig(configArgs, env, cwd);
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
-    const sourceFile = parsed.flags["--file"] ? path6.resolve(cwd, parsed.flags["--file"]) : "";
+    const sourceFile = parsed.flags["--file"] ? path7.resolve(cwd, parsed.flags["--file"]) : "";
     const useStdin = parsed.boolFlags.has("--stdin");
     const useJson = parsed.boolFlags.has("--json");
     const sourceCount = Number(Boolean(sourceFile)) + Number(useStdin);
@@ -2900,8 +4404,8 @@ function createIngestFeatureHandler(deps = {}) {
 }
 
 // src/runUpload.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import path7 from "node:path";
+import { readFileSync as readFileSync6 } from "node:fs";
+import path8 from "node:path";
 var STEP_RESULTS = [
   StepResult.Passed,
   StepResult.Failed,
@@ -3042,8 +4546,8 @@ function summarizeRunResult(result) {
   return lines;
 }
 function createRunUploadHandler(deps = {}) {
-  const readFile = deps.readFile ?? ((filePath) => readFileSync5(filePath, "utf8"));
-  const readStdin = deps.readStdin ?? (() => readFileSync5(0, "utf8"));
+  const readFile = deps.readFile ?? ((filePath) => readFileSync6(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => readFileSync6(0, "utf8"));
   const cwd = deps.cwd ?? process.cwd();
   const env = deps.env ?? process.env;
   return async (request, context) => {
@@ -3054,7 +4558,7 @@ function createRunUploadHandler(deps = {}) {
     const projectKey = config.values.projectKey;
     const issueKey = config.values.issueKey;
     const testCaseKey = parsed.flags["--test-case-key"]?.trim().toUpperCase() ?? "";
-    const sourceFile = parsed.flags["--file"] ? path7.resolve(cwd, parsed.flags["--file"]) : "";
+    const sourceFile = parsed.flags["--file"] ? path8.resolve(cwd, parsed.flags["--file"]) : "";
     const useStdin = parsed.boolFlags.has("--stdin");
     const useJson = parsed.boolFlags.has("--json");
     const sourceCount = Number(Boolean(sourceFile)) + Number(useStdin);
@@ -3900,8 +5404,8 @@ var COMMAND_REGISTRY = [
   },
   {
     name: "bdd",
-    description: "BDD scenario inspection commands",
-    subcommands: ["scenarios"],
+    description: "BDD scenario inspection and feature export commands",
+    subcommands: ["features", "scenarios"],
     handler: createBddHandler()
   },
   {