@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-M2RX3S2T.mjs

@@ -0,0 +1,49 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(x, {
+  get: (a, b) => (typeof require < "u" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};

package/dist/chunks/chunk-M3WPIJYM.mjs

@@ -0,0 +1,65 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  external_exports
+} from "./chunk-ZJKXHM4Q.mjs";
+
+// src/shared/types/form-hints.types.ts
+var FORM_CONTENT_TYPE = "application/vnd.adf.form+json", idPattern = /^[a-z0-9_-]+$/, FormOptionSchema = external_exports.object({
+  id: external_exports.string().min(1).max(8).regex(idPattern),
+  label: external_exports.string().min(1).max(100)
+}), FormQuestionSchema = external_exports.object({
+  id: external_exports.string().min(1).max(8).regex(idPattern),
+  text: external_exports.string().min(1).max(1e3),
+  type: external_exports.enum(["choice", "multi", "text"]),
+  options: external_exports.array(FormOptionSchema).min(1).max(12).optional(),
+  required: external_exports.boolean().optional()
+}).refine(
+  (q) => q.type === "text" || q.options && q.options.length > 0,
+  { message: "choice/multi questions require options" }
+), FormHintSchema = external_exports.object({
+  id: external_exports.string().min(1).max(16).regex(idPattern),
+  title: external_exports.string().max(200).optional(),
+  questions: external_exports.array(FormQuestionSchema).min(1).max(10),
+  /**
+   * REQUIRED rendering choice — the agent owns this decision; the adapter
+   * only validates and dispatches. A choice the form's shape doesn't satisfy
+   * fails the delivery with the precise reason. Telegram surfaces:
+   * 'poll' (native poll — single choice/multi question, 2-10 options,
+   * title+question <=300 chars, option labels <=100), 'compact' (one message,
+   * one combined keyboard — no text questions), 'per_question' (one message
+   * per question, any shape). Adapters without native form surfaces render
+   * the plain-text questionnaire regardless of this field.
+   */
+  render: external_exports.enum(["poll", "compact", "per_question"]),
+  /** Verbatim plain-text rendering used by adapters without native form support */
+  fallback_text: external_exports.string().max(4e3).optional()
+});
+function parseFormHint(value) {
+  let result = FormHintSchema.safeParse(value);
+  return result.success ? result.data : null;
+}
+function encodeFormAction(formId, questionId, optionId) {
+  return `f|${formId}|${questionId}|${optionId}`;
+}
+function decodeFormAction(data) {
+  let parts = data.split("|");
+  if (parts.length !== 4 || parts[0] !== "f") return null;
+  let [, formId, questionId, optionId] = parts;
+  return !formId || !questionId || !optionId ? null : { formId, questionId, optionId };
+}
+var FORM_MULTI_DONE = "__done", FORM_ANSWERED = "__answered";
+
+export {
+  FORM_CONTENT_TYPE,
+  FormHintSchema,
+  parseFormHint,
+  encodeFormAction,
+  decodeFormAction,
+  FORM_MULTI_DONE,
+  FORM_ANSWERED
+};

package/dist/chunks/chunk-NBTUWMGP.mjs

@@ -0,0 +1,263 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  a2hex,
+  findZero
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  fromBuffer
+} from "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  FieldDecodingError,
+  InternalParserError,
+  StringType,
+  UINT16_LE,
+  UINT32_LE,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError,
+  textDecode,
+  textEncode
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/apev2/APEv2Parser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/common/FourCC.js
+var validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/, FourCcToken = {
+  len: 4,
+  get: (buf, off) => {
+    let id = textDecode(buf.subarray(off, off + FourCcToken.len), "latin1");
+    if (!id.match(validFourCC))
+      throw new FieldDecodingError(`FourCC contains invalid characters: ${a2hex(id)} "${id}"`);
+    return id;
+  },
+  put: (buffer, offset, id) => {
+    let str = textEncode(id, "latin1");
+    if (str.length !== 4)
+      throw new InternalParserError("Invalid length");
+    return buffer.set(str, offset), offset + 4;
+  }
+};
+
+// node_modules/music-metadata/lib/apev2/APEv2Token.js
+var DataType = {
+  text_utf8: 0,
+  binary: 1,
+  external_info: 2,
+  reserved: 3
+}, DescriptorParser = {
+  len: 52,
+  get: (buf, off) => ({
+    // should equal 'MAC '
+    ID: FourCcToken.get(buf, off),
+    // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
+    version: UINT32_LE.get(buf, off + 4) / 1e3,
+    // the number of descriptor bytes (allows later expansion of this header)
+    descriptorBytes: UINT32_LE.get(buf, off + 8),
+    // the number of header APE_HEADER bytes
+    headerBytes: UINT32_LE.get(buf, off + 12),
+    // the number of header APE_HEADER bytes
+    seekTableBytes: UINT32_LE.get(buf, off + 16),
+    // the number of header data bytes (from original file)
+    headerDataBytes: UINT32_LE.get(buf, off + 20),
+    // the number of bytes of APE frame data
+    apeFrameDataBytes: UINT32_LE.get(buf, off + 24),
+    // the high order number of APE frame data bytes
+    apeFrameDataBytesHigh: UINT32_LE.get(buf, off + 28),
+    // the terminating data of the file (not including tag data)
+    terminatingDataBytes: UINT32_LE.get(buf, off + 32),
+    // the MD5 hash of the file (see notes for usage... it's a little tricky)
+    fileMD5: new Uint8ArrayType(16).get(buf, off + 36)
+  })
+}, Header = {
+  len: 24,
+  get: (buf, off) => ({
+    // the compression level (see defines I.E. COMPRESSION_LEVEL_FAST)
+    compressionLevel: UINT16_LE.get(buf, off),
+    // any format flags (for future use)
+    formatFlags: UINT16_LE.get(buf, off + 2),
+    // the number of audio blocks in one frame
+    blocksPerFrame: UINT32_LE.get(buf, off + 4),
+    // the number of audio blocks in the final frame
+    finalFrameBlocks: UINT32_LE.get(buf, off + 8),
+    // the total number of frames
+    totalFrames: UINT32_LE.get(buf, off + 12),
+    // the bits per sample (typically 16)
+    bitsPerSample: UINT16_LE.get(buf, off + 16),
+    // the number of channels (1 or 2)
+    channel: UINT16_LE.get(buf, off + 18),
+    // the sample rate (typically 44100)
+    sampleRate: UINT32_LE.get(buf, off + 20)
+  })
+}, TagFooter = {
+  len: 32,
+  get: (buf, off) => ({
+    // should equal 'APETAGEX'
+    ID: new StringType(8, "ascii").get(buf, off),
+    // equals CURRENT_APE_TAG_VERSION
+    version: UINT32_LE.get(buf, off + 8),
+    // the complete size of the tag, including this footer (excludes header)
+    size: UINT32_LE.get(buf, off + 12),
+    // the number of fields in the tag
+    fields: UINT32_LE.get(buf, off + 16),
+    // reserved for later use (must be zero),
+    flags: parseTagFlags(UINT32_LE.get(buf, off + 20))
+  })
+}, TagItemHeader = {
+  len: 8,
+  get: (buf, off) => ({
+    // Length of assigned value in bytes
+    size: UINT32_LE.get(buf, off),
+    // reserved for later use (must be zero),
+    flags: parseTagFlags(UINT32_LE.get(buf, off + 4))
+  })
+};
+function parseTagFlags(flags) {
+  return {
+    containsHeader: isBitSet(flags, 31),
+    containsFooter: isBitSet(flags, 30),
+    isHeader: isBitSet(flags, 29),
+    readOnly: isBitSet(flags, 0),
+    dataType: (flags & 6) >> 1
+  };
+}
+function isBitSet(num, bit) {
+  return (num & 1 << bit) !== 0;
+}
+
+// node_modules/music-metadata/lib/apev2/APEv2Parser.js
+var debug = (0, import_debug.default)("music-metadata:parser:APEv2"), tagFormat = "APEv2", preamble = "APETAGEX", ApeContentError = class extends makeUnexpectedFileContentError("APEv2") {
+};
+function tryParseApeHeader(metadata, tokenizer, options) {
+  return new APEv2Parser(metadata, tokenizer, options).tryParseApeHeader();
+}
+var APEv2Parser = class _APEv2Parser extends BasicParser {
+  constructor() {
+    super(...arguments), this.ape = {};
+  }
+  /**
+   * Calculate the media file duration
+   * @param ah ApeHeader
+   * @return {number} duration in seconds
+   */
+  static calculateDuration(ah) {
+    let duration = ah.totalFrames > 1 ? ah.blocksPerFrame * (ah.totalFrames - 1) : 0;
+    return duration += ah.finalFrameBlocks, duration / ah.sampleRate;
+  }
+  /**
+   * Calculates the APEv1 / APEv2 first field offset
+   * @param tokenizer
+   * @param offset
+   */
+  static async findApeFooterOffset(tokenizer, offset) {
+    let apeBuf = new Uint8Array(TagFooter.len), position = tokenizer.position;
+    if (offset <= TagFooter.len) {
+      debug(`Offset is too small to read APE footer: offset=${offset}`);
+      return;
+    }
+    if (offset > TagFooter.len) {
+      await tokenizer.readBuffer(apeBuf, { position: offset - TagFooter.len }), tokenizer.setPosition(position);
+      let tagFooter = TagFooter.get(apeBuf, 0);
+      if (tagFooter.ID === "APETAGEX")
+        return tagFooter.flags.isHeader ? debug(`APE Header found at offset=${offset - TagFooter.len}`) : (debug(`APE Footer found at offset=${offset - TagFooter.len}`), offset -= tagFooter.size), { footer: tagFooter, offset };
+    }
+  }
+  static parseTagFooter(metadata, buffer, options) {
+    let footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
+    if (footer.ID !== preamble)
+      throw new ApeContentError("Unexpected APEv2 Footer ID preamble value");
+    return fromBuffer(buffer), new _APEv2Parser(metadata, fromBuffer(buffer), options).parseTags(footer);
+  }
+  /**
+   * Parse APEv1 / APEv2 header if header signature found
+   */
+  async tryParseApeHeader() {
+    if (this.tokenizer.fileInfo.size && this.tokenizer.fileInfo.size - this.tokenizer.position < TagFooter.len) {
+      debug("No APEv2 header found, end-of-file reached");
+      return;
+    }
+    let footer = await this.tokenizer.peekToken(TagFooter);
+    if (footer.ID === preamble)
+      return await this.tokenizer.ignore(TagFooter.len), this.parseTags(footer);
+    if (debug(`APEv2 header not found at offset=${this.tokenizer.position}`), this.tokenizer.fileInfo.size) {
+      let remaining = this.tokenizer.fileInfo.size - this.tokenizer.position, buffer = new Uint8Array(remaining);
+      return await this.tokenizer.readBuffer(buffer), _APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
+    }
+  }
+  async parse() {
+    let descriptor = await this.tokenizer.readToken(DescriptorParser);
+    if (descriptor.ID !== "MAC ")
+      throw new ApeContentError("Unexpected descriptor ID");
+    this.ape.descriptor = descriptor;
+    let lenExp = descriptor.descriptorBytes - DescriptorParser.len, header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
+    return this.metadata.setAudioOnly(), await this.tokenizer.ignore(header.forwardBytes), this.tryParseApeHeader();
+  }
+  async parseTags(footer) {
+    let keyBuffer = new Uint8Array(256), bytesRemaining = footer.size - TagFooter.len;
+    debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
+    for (let i = 0; i < footer.fields; i++) {
+      if (bytesRemaining < TagItemHeader.len) {
+        this.metadata.addWarning(`APEv2 Tag-header: ${footer.fields - i} items remaining, but no more tag data to read.`);
+        break;
+      }
+      let tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
+      bytesRemaining -= TagItemHeader.len + tagItemHeader.size, await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
+      let zero = findZero(keyBuffer), key = await this.tokenizer.readToken(new StringType(zero, "ascii"));
+      switch (await this.tokenizer.ignore(1), bytesRemaining -= key.length + 1, tagItemHeader.flags.dataType) {
+        case DataType.text_utf8: {
+          let values = (await this.tokenizer.readToken(new StringType(tagItemHeader.size, "utf8"))).split(/\x00/g);
+          await Promise.all(values.map((val) => this.metadata.addTag(tagFormat, key, val)));
+          break;
+        }
+        case DataType.binary:
+          if (this.options.skipCovers)
+            await this.tokenizer.ignore(tagItemHeader.size);
+          else {
+            let picData = new Uint8Array(tagItemHeader.size);
+            await this.tokenizer.readBuffer(picData), zero = findZero(picData);
+            let description = textDecode(picData.subarray(0, zero), "utf-8"), data = picData.subarray(zero + 1);
+            await this.metadata.addTag(tagFormat, key, {
+              description,
+              data
+            });
+          }
+          break;
+        case DataType.external_info:
+          debug(`Ignore external info ${key}`), await this.tokenizer.ignore(tagItemHeader.size);
+          break;
+        case DataType.reserved:
+          debug(`Ignore external info ${key}`), this.metadata.addWarning(`APEv2 header declares a reserved datatype for "${key}"`), await this.tokenizer.ignore(tagItemHeader.size);
+          break;
+      }
+    }
+  }
+  async parseDescriptorExpansion(lenExp) {
+    return await this.tokenizer.ignore(lenExp), this.parseHeader();
+  }
+  async parseHeader() {
+    let header = await this.tokenizer.readToken(Header);
+    if (this.metadata.setFormat("lossless", !0), this.metadata.setFormat("container", "Monkey's Audio"), this.metadata.setFormat("bitsPerSample", header.bitsPerSample), this.metadata.setFormat("sampleRate", header.sampleRate), this.metadata.setFormat("numberOfChannels", header.channel), this.metadata.setFormat("duration", _APEv2Parser.calculateDuration(header)), !this.ape.descriptor)
+      throw new ApeContentError("Missing APE descriptor");
+    return {
+      forwardBytes: this.ape.descriptor.seekTableBytes + this.ape.descriptor.headerDataBytes + this.ape.descriptor.apeFrameDataBytes + this.ape.descriptor.terminatingDataBytes
+    };
+  }
+};
+
+export {
+  FourCcToken,
+  ApeContentError,
+  tryParseApeHeader,
+  APEv2Parser
+};