@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-5W7KES6P.mjs

@@ -0,0 +1,436 @@
+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);
+
+// src/main/tools/shell/parser/tokenizer.ts
+function parseBracedExpansion(content) {
+  let m = content.match(/^([A-Za-z_][A-Za-z0-9_]*|\?)/);
+  if (!m) return { name: content };
+  let name = m[1], rest = content.slice(name.length);
+  if (!rest) return { name };
+  let opMatch = rest.match(/^(:?[-=?+])/) ?? rest.match(/^(##|%%|[#%/^,])/);
+  return opMatch ? { name, op: opMatch[1], word: rest.slice(opMatch[1].length) } : { name: content };
+}
+function tokenize(input) {
+  let tokens = [], i = 0, len = input.length, lastEnd = -1, heredocMarkers = [], heredocPending = !1;
+  for (; i < len; ) {
+    let startPos = i, ch = input[i];
+    if (ch === " " || ch === "	") {
+      i++;
+      continue;
+    }
+    if (ch === "#") {
+      for (; i < len && input[i] !== `
+`; ) i++;
+      continue;
+    }
+    if (ch === `
+`) {
+      if (heredocPending && heredocMarkers.length > 0) {
+        let marker = heredocMarkers.shift(), bodyStart = i + 1, endPattern = `
+` + marker, bodyEnd = input.indexOf(endPattern, bodyStart);
+        if (bodyEnd === -1) {
+          let altEnd = input.indexOf(marker, bodyStart);
+          altEnd !== -1 && (altEnd === bodyStart || input[altEnd - 1] === `
+`) ? (bodyEnd = altEnd - 1, tokens.push({ type: "heredoc_body", value: input.slice(bodyStart, bodyEnd < bodyStart ? bodyStart : bodyEnd) }), i = altEnd + marker.length) : (tokens.push({ type: "heredoc_body", value: input.slice(bodyStart) }), i = len);
+        } else
+          tokens.push({ type: "heredoc_body", value: input.slice(bodyStart, bodyEnd) }), i = bodyEnd + endPattern.length;
+        heredocMarkers.length === 0 && (heredocPending = !1);
+        continue;
+      }
+      let last = tokens[tokens.length - 1];
+      tokens.length > 0 && last.type !== "semi" && last.type !== "amp" && tokens.push({ type: "semi", value: ";" }), i++;
+      continue;
+    }
+    if (i + 1 < len) {
+      let two = input[i] + input[i + 1];
+      if (two === "&&") {
+        tokens.push({ type: "and", value: "&&" }), i += 2;
+        continue;
+      }
+      if (two === "||") {
+        tokens.push({ type: "or", value: "||" }), i += 2;
+        continue;
+      }
+      if (two === ">>") {
+        tokens.push({ type: "redirect_append", value: ">>", ...startPos === lastEnd ? { glued: !0 } : {} }), i += 2;
+        continue;
+      }
+      if (two === "<<") {
+        for (i += 2; i < len && (input[i] === " " || input[i] === "	"); ) i++;
+        let quoteChar = "";
+        i < len && (input[i] === "'" || input[i] === '"') && (quoteChar = input[i], i++);
+        let tag = "";
+        for (; i < len && input[i] !== " " && input[i] !== "	" && input[i] !== `
+` && input[i] !== quoteChar; )
+          tag += input[i], i++;
+        quoteChar && i < len && input[i] === quoteChar && i++, tokens.push({ type: "heredoc_marker", value: tag, ...quoteChar ? { quoted: !0 } : {} }), heredocMarkers.push(tag), heredocPending = !0;
+        continue;
+      }
+    }
+    if (ch === "|") {
+      tokens.push({ type: "pipe", value: "|" }), i++;
+      continue;
+    }
+    if (ch === ">") {
+      tokens.push({ type: "redirect_out", value: ">", ...startPos === lastEnd ? { glued: !0 } : {} }), i++;
+      continue;
+    }
+    if (ch === "<") {
+      tokens.push({ type: "redirect_in", value: "<", ...startPos === lastEnd ? { glued: !0 } : {} }), i++;
+      continue;
+    }
+    if (ch === ";") {
+      tokens.push({ type: "semi", value: ";" }), i++;
+      continue;
+    }
+    if (ch === "&") {
+      let prev = tokens[tokens.length - 1];
+      if (i + 1 < len && /[0-9]/.test(input[i + 1]) && prev && (prev.type === "redirect_out" || prev.type === "redirect_append" || prev.type === "redirect_in")) {
+        i++;
+        let fd = "";
+        for (; i < len && /[0-9]/.test(input[i]); )
+          fd += input[i], i++;
+        tokens.push({ type: "redirect_dup", value: fd });
+        continue;
+      }
+      tokens.push({ type: "amp", value: "&" }), i++;
+      continue;
+    }
+    if (ch === "$" && i + 1 < len && input[i + 1] === "(") {
+      i += 2;
+      let depth = 1, inner = "";
+      for (; i < len && depth > 0; ) {
+        if (input[i] === "(") depth++;
+        else if (input[i] === ")" && (depth--, depth === 0))
+          break;
+        inner += input[i], i++;
+      }
+      i < len && i++, tokens.push({ type: "substitution", value: inner, ...startPos === lastEnd ? { glued: !0 } : {} }), lastEnd = i;
+      continue;
+    }
+    if (ch === "$" && i + 1 < len) {
+      let glued = startPos === lastEnd ? { glued: !0 } : {};
+      if (i++, input[i] === "{") {
+        i++;
+        let content = "";
+        for (; i < len && input[i] !== "}"; )
+          content += input[i], i++;
+        i < len && i++;
+        let exp = parseBracedExpansion(content);
+        tokens.push({
+          type: "variable",
+          value: exp.name,
+          ...exp.op !== void 0 ? { op: exp.op, word: exp.word ?? "" } : {},
+          ...glued
+        });
+      } else if (input[i] === "?")
+        i++, tokens.push({ type: "variable", value: "?", ...glued });
+      else {
+        let name = "";
+        for (; i < len && /[a-zA-Z0-9_]/.test(input[i]); )
+          name += input[i], i++;
+        name ? tokens.push({ type: "variable", value: name, ...glued }) : tokens.push({ type: "word", value: "$", ...glued });
+      }
+      lastEnd = i;
+      continue;
+    }
+    if (ch === "'") {
+      i++;
+      let val = "";
+      for (; i < len && input[i] !== "'"; )
+        val += input[i], i++;
+      i < len && i++, tokens.push({ type: "single_quoted", value: val, ...startPos === lastEnd ? { glued: !0 } : {} }), lastEnd = i;
+      continue;
+    }
+    if (ch === '"') {
+      i++;
+      let raw = "";
+      for (; i < len && input[i] !== '"'; )
+        if (input[i] === "\\" && i + 1 < len) {
+          let next = input[i + 1];
+          next === '"' || next === "\\" || next === "$" || next === "`" ? raw += next : raw += "\\" + next, i += 2;
+        } else
+          raw += input[i], i++;
+      i < len && i++, tokens.push({ type: "double_quoted", value: raw, raw, ...startPos === lastEnd ? { glued: !0 } : {} }), lastEnd = i;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < len) {
+      if (i++, input[i] === `
+`) {
+        i++;
+        continue;
+      }
+      tokens.push({ type: "word", value: input[i], ...startPos === lastEnd ? { glued: !0 } : {} }), i++, lastEnd = i;
+      continue;
+    }
+    let word = "";
+    for (; i < len && input[i] !== " " && input[i] !== "	" && input[i] !== `
+` && input[i] !== "|" && input[i] !== ">" && input[i] !== "<" && input[i] !== ";" && input[i] !== "&" && input[i] !== "$" && input[i] !== '"' && input[i] !== "'" && input[i] !== "#" && input[i] !== "(" && input[i] !== ")"; )
+      input[i] === "\\" && i + 1 < len ? (word += input[i + 1], i += 2) : (word += input[i], i++);
+    word && (tokens.push({ type: "word", value: word, ...startPos === lastEnd ? { glued: !0 } : {} }), lastEnd = i), i === startPos && i++;
+  }
+  for (; tokens.length > 0 && tokens[tokens.length - 1].type === "semi"; )
+    tokens.pop();
+  return tokens.push({ type: "eof", value: "" }), tokens;
+}
+
+// src/main/tools/shell/parser/parser.ts
+var ParseError = class extends Error {
+  constructor(msg) {
+    super(msg), this.name = "ParseError";
+  }
+};
+function classifyRedirectTarget(path) {
+  let normalized = path.replace(/^\.\//, "").replace(/^\//, "");
+  return normalized === "dev/null" ? "null" : normalized === "dev/stdout" ? "stdout" : normalized === "dev/stderr" ? "stderr" : null;
+}
+function unsupportedDevTargetMessage(special) {
+  return special === "stdout" ? "redirect to /dev/stdout is not supported in adf_shell; use 2>&1 to merge stderr into stdout" : "redirect to /dev/stderr is not supported in adf_shell; use >&2 to send stdout to stderr";
+}
+function staticStringOf(arg) {
+  switch (arg.type) {
+    case "literal":
+      return arg.value;
+    case "quoted": {
+      let out = "";
+      for (let part of arg.parts) {
+        let s = staticStringOf(part);
+        if (s === null) return null;
+        out += s;
+      }
+      return out;
+    }
+    default:
+      return null;
+  }
+}
+var Parser = class _Parser {
+  tokens;
+  pos;
+  constructor(tokens) {
+    this.tokens = tokens, this.pos = 0;
+  }
+  peek() {
+    return this.tokens[this.pos] ?? { type: "eof", value: "" };
+  }
+  advance() {
+    let t = this.tokens[this.pos];
+    return this.pos++, t;
+  }
+  expect(type) {
+    let t = this.peek();
+    if (t.type !== type)
+      throw new ParseError(`Expected ${type}, got ${t.type} ("${t.value}")`);
+    return this.advance();
+  }
+  isChainOp(t) {
+    return t.type === "and" || t.type === "or" || t.type === "semi" || t.type === "amp";
+  }
+  isRedirect(t) {
+    return t.type === "redirect_out" || t.type === "redirect_append" || t.type === "redirect_in";
+  }
+  isArg(t) {
+    return t.type === "word" || t.type === "single_quoted" || t.type === "double_quoted" || t.type === "variable" || t.type === "substitution";
+  }
+  /** Validate a ${VAR<op>word} operator — only default expansion is supported */
+  checkExpansionOp(name, op) {
+    if (op !== "-" && op !== ":-")
+      throw new ParseError(
+        `\${${name}${op}...}: only \${VAR-default} and \${VAR:-default} expansion is supported in adf_shell`
+      );
+  }
+  /** Parse a token into an ArgumentNode */
+  parseArg(t) {
+    switch (t.type) {
+      case "word":
+        return { type: "literal", value: t.value };
+      case "variable":
+        return t.op !== void 0 ? (this.checkExpansionOp(t.value, t.op), { type: "variable", name: t.value, op: t.op, word: t.word ?? "" }) : { type: "variable", name: t.value };
+      case "substitution":
+        return { type: "substitution", pipeline: this.parseSubstitution(t.value) };
+      case "single_quoted":
+        return { type: "quoted", quote: "single", parts: [{ type: "literal", value: t.value }] };
+      case "double_quoted":
+        return { type: "quoted", quote: "double", parts: this.parseDoubleQuoted(t.value) };
+      default:
+        throw new ParseError(`Unexpected token type ${t.type} in argument position`);
+    }
+  }
+  /** Parse a maximal run of GLUED word-like tokens starting at `first` into
+   *  ONE argument. Bash treats adjacent unspaced segments as a single word
+   *  (`gate_exit=$?`, `"pre"$VAR"post"`, `x$?y`) — emitting them as separate
+   *  args split what the user wrote as one. All-literal runs collapse back to
+   *  a single literal so unquoted glob characters still expand. */
+  parseGluedWord(first) {
+    let parts = [this.parseArg(first)];
+    for (; this.peek().glued && this.isArg(this.peek()); )
+      parts.push(this.parseArg(this.advance()));
+    return parts.length === 1 ? parts[0] : parts.every((p) => p.type === "literal") ? { type: "literal", value: parts.map((p) => p.value).join("") } : { type: "quoted", quote: "double", parts };
+  }
+  /** Parse the content of a double-quoted string into parts (literal + variable + substitution) */
+  parseDoubleQuoted(raw) {
+    let parts = [], i = 0, literal = "";
+    for (; i < raw.length; )
+      if (raw[i] === "$" && i + 1 < raw.length)
+        if (literal && (parts.push({ type: "literal", value: literal }), literal = ""), raw[i + 1] === "(") {
+          i += 2;
+          let depth = 1, inner = "";
+          for (; i < raw.length && depth > 0; ) {
+            if (raw[i] === "(") depth++;
+            else if (raw[i] === ")" && (depth--, depth === 0))
+              break;
+            inner += raw[i], i++;
+          }
+          i < raw.length && i++, parts.push({ type: "substitution", pipeline: this.parseSubstitution(inner) });
+        } else if (raw[i + 1] === "{") {
+          i += 2;
+          let content = "";
+          for (; i < raw.length && raw[i] !== "}"; )
+            content += raw[i], i++;
+          i < raw.length && i++;
+          let exp = parseBracedExpansion(content);
+          exp.op !== void 0 ? (this.checkExpansionOp(exp.name, exp.op), parts.push({ type: "variable", name: exp.name, op: exp.op, word: exp.word ?? "" })) : parts.push({ type: "variable", name: exp.name });
+        } else if (raw[i + 1] === "?")
+          i += 2, parts.push({ type: "variable", name: "?" });
+        else {
+          i++;
+          let name = "";
+          for (; i < raw.length && /[a-zA-Z0-9_]/.test(raw[i]); )
+            name += raw[i], i++;
+          name ? parts.push({ type: "variable", name }) : literal += "$";
+        }
+      else
+        literal += raw[i], i++;
+    return literal && parts.push({ type: "literal", value: literal }), parts.length > 0 ? parts : [{ type: "literal", value: "" }];
+  }
+  /** Parse a command substitution string into a PipelineNode */
+  parseSubstitution(inner) {
+    if (inner.startsWith("(") && inner.trimEnd().endsWith(")"))
+      throw new ParseError(
+        "arithmetic expansion $(( )) is not supported in adf_shell \u2014 use jq or a .js script"
+      );
+    let subTokens = tokenize(inner), node = new _Parser(subTokens).parseShell();
+    return node.kind === "pipeline" ? node : node.left;
+  }
+  // --- Grammar rules ---
+  parseShell() {
+    if (this.peek().type === "eof")
+      return { kind: "pipeline", stages: [] };
+    let node = this.parseChain(), rest = this.peek();
+    if (rest.type !== "eof")
+      throw new ParseError(`unexpected ${rest.type}${rest.value ? ` ("${rest.value}")` : ""} \u2014 the rest of the command was not understood`);
+    return node;
+  }
+  parseChain() {
+    let left = this.parsePipeline();
+    for (; this.isChainOp(this.peek()); ) {
+      let opToken = this.advance();
+      if (opToken.type === "amp")
+        throw new ParseError(
+          "background execution (&) is not supported in adf_shell; commands run in the foreground \u2014 remove the & or use && or ;"
+        );
+      let operator = opToken.value === "&&" ? "&&" : opToken.value === "||" ? "||" : ";";
+      if (operator !== ";")
+        for (; this.peek().type === "semi"; ) this.advance();
+      if (this.peek().type === "eof") return left;
+      let right = this.parseChain();
+      left = { kind: "chain", left, operator, right };
+    }
+    return left;
+  }
+  parsePipeline() {
+    let stages = [this.parseCommand()];
+    for (; this.peek().type === "pipe"; ) {
+      for (this.advance(); this.peek().type === "semi"; ) this.advance();
+      stages.push(this.parseCommand());
+    }
+    return { kind: "pipeline", stages };
+  }
+  parseCommand() {
+    let assignments = [];
+    for (; this.peek().type === "word" && /^[A-Za-z_][A-Za-z0-9_]*=/.test(this.peek().value); ) {
+      let tok = this.advance(), eq = tok.value.indexOf("="), parts = [], rest = tok.value.slice(eq + 1);
+      for (rest && parts.push({ type: "literal", value: rest }); this.peek().glued && this.isArg(this.peek()); )
+        parts.push(this.parseArg(this.advance()));
+      assignments.push({ name: tok.value.slice(0, eq), value: parts });
+    }
+    let nameToken = this.peek();
+    if (!this.isArg(nameToken) && nameToken.type !== "heredoc_marker") {
+      if (assignments.length > 0)
+        return { kind: "command", name: "", args: [], redirects: [], assignments };
+      throw new ParseError(`Expected command name, got ${nameToken.type} ("${nameToken.value}")`);
+    }
+    this.advance();
+    let name = nameToken.value, args = [], redirects = [], heredoc;
+    for (; this.peek().type !== "eof"; ) {
+      let t = this.peek();
+      if (t.type === "pipe" || this.isChainOp(t)) break;
+      if (this.isRedirect(t)) {
+        let fdNum = t.type === "redirect_in" ? 0 : 1;
+        if (t.glued && args.length > 0) {
+          let lastArg = args[args.length - 1];
+          lastArg.type === "literal" && /^[0-9]$/.test(lastArg.value) && (fdNum = parseInt(lastArg.value, 10), args.pop());
+        }
+        this.advance();
+        let targetToken = this.peek();
+        if (targetToken.type === "redirect_dup") {
+          this.advance(), t.type !== "redirect_in" && redirects.push({ type: "dup", fd: fdNum, targetFd: parseInt(targetToken.value, 10) });
+          continue;
+        }
+        if (!this.isArg(targetToken))
+          throw new ParseError(`Expected redirect target, got ${targetToken.type}`);
+        this.advance();
+        let targetArg = this.parseGluedWord(targetToken), staticTarget = staticStringOf(targetArg);
+        if (staticTarget !== null) {
+          let special = classifyRedirectTarget(staticTarget);
+          if (special === "null") {
+            redirects.push({ type: "discard", fd: fdNum });
+            continue;
+          }
+          if (special)
+            throw new ParseError(unsupportedDevTargetMessage(special));
+        }
+        let rType = t.type === "redirect_in" ? "in" : t.type === "redirect_append" ? "append" : "out", targetProp = staticTarget !== null ? { target: staticTarget } : { targetNode: targetArg };
+        rType === "in" ? redirects.push({ type: "in", ...targetProp }) : redirects.push({ type: rType, ...targetProp, ...fdNum !== 1 ? { fd: fdNum } : {} });
+        continue;
+      }
+      if (t.type === "heredoc_marker") {
+        if (t.value === "")
+          throw new ParseError("heredoc needs a tag: use `<< EOF` (or `<< 'EOF'` to keep the body literal) and end the body with EOF on its own line");
+        this.advance();
+        let bodyToken = this.peek(), quoted = t.quoted ? { quoted: !0 } : {};
+        bodyToken.type === "heredoc_body" ? (this.advance(), heredoc = { tag: t.value, content: bodyToken.value, ...quoted }) : heredoc = { tag: t.value, content: "", ...quoted };
+        continue;
+      }
+      if (this.isArg(t)) {
+        args.push(this.parseGluedWord(this.advance()));
+        continue;
+      }
+      break;
+    }
+    return {
+      kind: "command",
+      name,
+      args,
+      redirects,
+      heredoc,
+      ...assignments.length > 0 ? { assignments } : {}
+    };
+  }
+};
+function parse(input) {
+  let tokens = tokenize(input);
+  return new Parser(tokens).parseShell();
+}
+
+export {
+  parseBracedExpansion,
+  ParseError,
+  classifyRedirectTarget,
+  unsupportedDevTargetMessage,
+  parse
+};

package/dist/chunks/chunk-62NE4LG4.mjs

@@ -0,0 +1,61 @@
+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 {
+  ID3v2Parser
+} from "./chunk-XYTWGHFS.mjs";
+import {
+  ID3v1Parser
+} from "./chunk-VAUOM3IN.mjs";
+import {
+  ID3v2Header
+} from "./chunk-DXWDD5XJ.mjs";
+import {
+  EndOfStreamError
+} from "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/id3v2/AbstractID3Parser.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:ID3"), AbstractID3Parser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.id3parser = new ID3v2Parser();
+  }
+  static async startsWithID3v2Header(tokenizer) {
+    return (await tokenizer.peekToken(ID3v2Header)).fileIdentifier === "ID3";
+  }
+  async parse() {
+    try {
+      await this.parseID3v2();
+    } catch (err) {
+      if (err instanceof EndOfStreamError)
+        debug("End-of-stream");
+      else
+        throw err;
+    }
+  }
+  finalize() {
+  }
+  async parseID3v2() {
+    await this.tryReadId3v2Headers(), debug("End of ID3v2 header, go to MPEG-parser: pos=%s", this.tokenizer.position), await this.postId3v2Parse(), this.options.skipPostHeaders && this.metadata.hasAny() ? this.finalize() : (await new ID3v1Parser(this.metadata, this.tokenizer, this.options).parse(), this.finalize());
+  }
+  async tryReadId3v2Headers() {
+    if ((await this.tokenizer.peekToken(ID3v2Header)).fileIdentifier === "ID3")
+      return debug("Found ID3v2 header, pos=%s", this.tokenizer.position), await this.id3parser.parse(this.metadata, this.tokenizer, this.options), this.tryReadId3v2Headers();
+  }
+};
+
+export {
+  AbstractID3Parser
+};

package/dist/chunks/chunk-64OKE4X3.mjs

@@ -0,0 +1,45 @@
+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 {
+  __commonJS
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+  "node_modules/fast-deep-equal/index.js"(exports, module) {
+    "use strict";
+    module.exports = function equal(a, b) {
+      if (a === b) return !0;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor) return !1;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          if (length = a.length, length != b.length) return !1;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i])) return !1;
+          return !0;
+        }
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+        if (keys = Object.keys(a), length = keys.length, length !== Object.keys(b).length) return !1;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return !1;
+        for (i = length; i-- !== 0; ) {
+          var key = keys[i];
+          if (!equal(a[key], b[key])) return !1;
+        }
+        return !0;
+      }
+      return a !== a && b !== b;
+    };
+  }
+});
+
+export {
+  require_fast_deep_equal
+};