@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-HBUENVQL.mjs

@@ -0,0 +1,570 @@
+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);
+
+// node_modules/strtok3/lib/stream/Errors.js
+var defaultMessages = "End-Of-Stream", EndOfStreamError = class extends Error {
+  constructor() {
+    super(defaultMessages), this.name = "EndOfStreamError";
+  }
+}, AbortError = class extends Error {
+  constructor(message = "The operation was aborted") {
+    super(message), this.name = "AbortError";
+  }
+};
+
+// node_modules/strtok3/lib/stream/Deferred.js
+var Deferred = class {
+  constructor() {
+    this.resolve = () => null, this.reject = () => null, this.promise = new Promise((resolve, reject) => {
+      this.reject = reject, this.resolve = resolve;
+    });
+  }
+};
+
+// node_modules/strtok3/lib/stream/AbstractStreamReader.js
+var AbstractStreamReader = class {
+  constructor() {
+    this.endOfStream = !1, this.interrupted = !1, this.peekQueue = [];
+  }
+  async peek(uint8Array, mayBeLess = !1) {
+    let bytesRead = await this.read(uint8Array, mayBeLess);
+    return this.peekQueue.push(uint8Array.subarray(0, bytesRead)), bytesRead;
+  }
+  async read(buffer, mayBeLess = !1) {
+    if (buffer.length === 0)
+      return 0;
+    let bytesRead = this.readFromPeekBuffer(buffer);
+    if (this.endOfStream || (bytesRead += await this.readRemainderFromStream(buffer.subarray(bytesRead), mayBeLess)), bytesRead === 0 && !mayBeLess)
+      throw new EndOfStreamError();
+    return bytesRead;
+  }
+  /**
+   * Read chunk from stream
+   * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+   * @returns Number of bytes read
+   */
+  readFromPeekBuffer(buffer) {
+    let remaining = buffer.length, bytesRead = 0;
+    for (; this.peekQueue.length > 0 && remaining > 0; ) {
+      let peekData = this.peekQueue.pop();
+      if (!peekData)
+        throw new Error("peekData should be defined");
+      let lenCopy = Math.min(peekData.length, remaining);
+      buffer.set(peekData.subarray(0, lenCopy), bytesRead), bytesRead += lenCopy, remaining -= lenCopy, lenCopy < peekData.length && this.peekQueue.push(peekData.subarray(lenCopy));
+    }
+    return bytesRead;
+  }
+  async readRemainderFromStream(buffer, mayBeLess) {
+    let bytesRead = 0;
+    for (; bytesRead < buffer.length && !this.endOfStream; ) {
+      if (this.interrupted)
+        throw new AbortError();
+      let chunkLen = await this.readFromStream(buffer.subarray(bytesRead), mayBeLess);
+      if (chunkLen === 0)
+        break;
+      bytesRead += chunkLen;
+    }
+    if (!mayBeLess && bytesRead < buffer.length)
+      throw new EndOfStreamError();
+    return bytesRead;
+  }
+};
+
+// node_modules/strtok3/lib/stream/StreamReader.js
+var StreamReader = class extends AbstractStreamReader {
+  constructor(s) {
+    if (super(), this.s = s, this.deferred = null, !s.read || !s.once)
+      throw new Error("Expected an instance of stream.Readable");
+    this.s.once("end", () => {
+      this.endOfStream = !0, this.deferred && this.deferred.resolve(0);
+    }), this.s.once("error", (err) => this.reject(err)), this.s.once("close", () => this.abort());
+  }
+  /**
+   * Read chunk from stream
+   * @param buffer Target Uint8Array (or Buffer) to store data read from stream in
+   * @param mayBeLess - If true, may fill the buffer partially
+   * @returns Number of bytes read
+   */
+  async readFromStream(buffer, mayBeLess) {
+    if (buffer.length === 0)
+      return 0;
+    let readBuffer = this.s.read(buffer.length);
+    if (readBuffer)
+      return buffer.set(readBuffer), readBuffer.length;
+    let request = {
+      buffer,
+      mayBeLess,
+      deferred: new Deferred()
+    };
+    return this.deferred = request.deferred, this.s.once("readable", () => {
+      this.readDeferred(request);
+    }), request.deferred.promise;
+  }
+  /**
+   * Process deferred read request
+   * @param request Deferred read request
+   */
+  readDeferred(request) {
+    let readBuffer = this.s.read(request.buffer.length);
+    readBuffer ? (request.buffer.set(readBuffer), request.deferred.resolve(readBuffer.length), this.deferred = null) : this.s.once("readable", () => {
+      this.readDeferred(request);
+    });
+  }
+  reject(err) {
+    this.interrupted = !0, this.deferred && (this.deferred.reject(err), this.deferred = null);
+  }
+  async abort() {
+    this.reject(new AbortError());
+  }
+  async close() {
+    return this.abort();
+  }
+};
+
+// node_modules/strtok3/lib/stream/WebStreamReader.js
+var WebStreamReader = class extends AbstractStreamReader {
+  constructor(reader) {
+    super(), this.reader = reader;
+  }
+  async abort() {
+    return this.close();
+  }
+  async close() {
+    this.reader.releaseLock();
+  }
+};
+
+// node_modules/strtok3/lib/stream/WebStreamByobReader.js
+var WebStreamByobReader = class extends WebStreamReader {
+  /**
+   * Read from stream
+   * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+   * @param mayBeLess - If true, may fill the buffer partially
+   * @protected Bytes read
+   */
+  async readFromStream(buffer, mayBeLess) {
+    if (buffer.length === 0)
+      return 0;
+    let result = await this.reader.read(new Uint8Array(buffer.length), { min: mayBeLess ? void 0 : buffer.length });
+    return result.done && (this.endOfStream = result.done), result.value ? (buffer.set(result.value), result.value.length) : 0;
+  }
+};
+
+// node_modules/strtok3/lib/stream/WebStreamDefaultReader.js
+var WebStreamDefaultReader = class extends AbstractStreamReader {
+  constructor(reader) {
+    super(), this.reader = reader, this.buffer = null;
+  }
+  /**
+   * Copy chunk to target, and store the remainder in this.buffer
+   */
+  writeChunk(target, chunk) {
+    let written = Math.min(chunk.length, target.length);
+    return target.set(chunk.subarray(0, written)), written < chunk.length ? this.buffer = chunk.subarray(written) : this.buffer = null, written;
+  }
+  /**
+   * Read from stream
+   * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+   * @param mayBeLess - If true, may fill the buffer partially
+   * @protected Bytes read
+   */
+  async readFromStream(buffer, mayBeLess) {
+    if (buffer.length === 0)
+      return 0;
+    let totalBytesRead = 0;
+    for (this.buffer && (totalBytesRead += this.writeChunk(buffer, this.buffer)); totalBytesRead < buffer.length && !this.endOfStream; ) {
+      let result = await this.reader.read();
+      if (result.done) {
+        this.endOfStream = !0;
+        break;
+      }
+      result.value && (totalBytesRead += this.writeChunk(buffer.subarray(totalBytesRead), result.value));
+    }
+    if (!mayBeLess && totalBytesRead === 0 && this.endOfStream)
+      throw new EndOfStreamError();
+    return totalBytesRead;
+  }
+  abort() {
+    return this.interrupted = !0, this.reader.cancel();
+  }
+  async close() {
+    await this.abort(), this.reader.releaseLock();
+  }
+};
+
+// node_modules/strtok3/lib/stream/WebStreamReaderFactory.js
+function makeWebStreamReader(stream) {
+  try {
+    let reader = stream.getReader({ mode: "byob" });
+    return reader instanceof ReadableStreamDefaultReader ? new WebStreamDefaultReader(reader) : new WebStreamByobReader(reader);
+  } catch (error) {
+    if (error instanceof TypeError)
+      return new WebStreamDefaultReader(stream.getReader());
+    throw error;
+  }
+}
+
+// node_modules/strtok3/lib/AbstractTokenizer.js
+var AbstractTokenizer = class {
+  /**
+   * Constructor
+   * @param options Tokenizer options
+   * @protected
+   */
+  constructor(options) {
+    this.numBuffer = new Uint8Array(8), this.position = 0, this.onClose = options?.onClose, options?.abortSignal && options.abortSignal.addEventListener("abort", () => {
+      this.abort();
+    });
+  }
+  /**
+   * Read a token from the tokenizer-stream
+   * @param token - The token to read
+   * @param position - If provided, the desired position in the tokenizer-stream
+   * @returns Promise with token data
+   */
+  async readToken(token, position = this.position) {
+    let uint8Array = new Uint8Array(token.len);
+    if (await this.readBuffer(uint8Array, { position }) < token.len)
+      throw new EndOfStreamError();
+    return token.get(uint8Array, 0);
+  }
+  /**
+   * Peek a token from the tokenizer-stream.
+   * @param token - Token to peek from the tokenizer-stream.
+   * @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
+   * @returns Promise with token data
+   */
+  async peekToken(token, position = this.position) {
+    let uint8Array = new Uint8Array(token.len);
+    if (await this.peekBuffer(uint8Array, { position }) < token.len)
+      throw new EndOfStreamError();
+    return token.get(uint8Array, 0);
+  }
+  /**
+   * Read a numeric token from the stream
+   * @param token - Numeric token
+   * @returns Promise with number
+   */
+  async readNumber(token) {
+    if (await this.readBuffer(this.numBuffer, { length: token.len }) < token.len)
+      throw new EndOfStreamError();
+    return token.get(this.numBuffer, 0);
+  }
+  /**
+   * Read a numeric token from the stream
+   * @param token - Numeric token
+   * @returns Promise with number
+   */
+  async peekNumber(token) {
+    if (await this.peekBuffer(this.numBuffer, { length: token.len }) < token.len)
+      throw new EndOfStreamError();
+    return token.get(this.numBuffer, 0);
+  }
+  /**
+   * Ignore number of bytes, advances the pointer in under tokenizer-stream.
+   * @param length - Number of bytes to ignore.  Must be ≥ 0.
+   * @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
+   */
+  async ignore(length) {
+    if (length < 0)
+      throw new RangeError("ignore length must be \u2265 0 bytes");
+    if (this.fileInfo.size !== void 0) {
+      let bytesLeft = this.fileInfo.size - this.position;
+      if (length > bytesLeft)
+        return this.position += bytesLeft, bytesLeft;
+    }
+    return this.position += length, length;
+  }
+  async close() {
+    await this.abort(), await this.onClose?.();
+  }
+  normalizeOptions(uint8Array, options) {
+    if (!this.supportsRandomAccess() && options && options.position !== void 0 && options.position < this.position)
+      throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+    return {
+      mayBeLess: !1,
+      offset: 0,
+      length: uint8Array.length,
+      position: this.position,
+      ...options
+    };
+  }
+  abort() {
+    return Promise.resolve();
+  }
+};
+
+// node_modules/strtok3/lib/ReadStreamTokenizer.js
+var maxBufferSize = 256e3, ReadStreamTokenizer = class extends AbstractTokenizer {
+  /**
+   * Constructor
+   * @param streamReader stream-reader to read from
+   * @param options Tokenizer options
+   */
+  constructor(streamReader, options) {
+    super(options), this.streamReader = streamReader, this.fileInfo = options?.fileInfo ?? {};
+  }
+  /**
+   * Read buffer from tokenizer
+   * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
+   * @param options - Read behaviour options
+   * @returns Promise with number of bytes read
+   */
+  async readBuffer(uint8Array, options) {
+    let normOptions = this.normalizeOptions(uint8Array, options), skipBytes = normOptions.position - this.position;
+    if (skipBytes > 0)
+      return await this.ignore(skipBytes), this.readBuffer(uint8Array, options);
+    if (skipBytes < 0)
+      throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+    if (normOptions.length === 0)
+      return 0;
+    let bytesRead = await this.streamReader.read(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
+    if (this.position += bytesRead, (!options || !options.mayBeLess) && bytesRead < normOptions.length)
+      throw new EndOfStreamError();
+    return bytesRead;
+  }
+  /**
+   * Peek (read ahead) buffer from tokenizer
+   * @param uint8Array - Uint8Array (or Buffer) to write data to
+   * @param options - Read behaviour options
+   * @returns Promise with number of bytes peeked
+   */
+  async peekBuffer(uint8Array, options) {
+    let normOptions = this.normalizeOptions(uint8Array, options), bytesRead = 0;
+    if (normOptions.position) {
+      let skipBytes = normOptions.position - this.position;
+      if (skipBytes > 0) {
+        let skipBuffer = new Uint8Array(normOptions.length + skipBytes);
+        return bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess }), uint8Array.set(skipBuffer.subarray(skipBytes)), bytesRead - skipBytes;
+      }
+      if (skipBytes < 0)
+        throw new Error("Cannot peek from a negative offset in a stream");
+    }
+    if (normOptions.length > 0) {
+      try {
+        bytesRead = await this.streamReader.peek(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
+      } catch (err) {
+        if (options?.mayBeLess && err instanceof EndOfStreamError)
+          return 0;
+        throw err;
+      }
+      if (!normOptions.mayBeLess && bytesRead < normOptions.length)
+        throw new EndOfStreamError();
+    }
+    return bytesRead;
+  }
+  /**
+   * @param length Number of bytes to ignore. Must be ≥ 0.
+   */
+  async ignore(length) {
+    if (length < 0)
+      throw new RangeError("ignore length must be \u2265 0 bytes");
+    let bufSize = Math.min(maxBufferSize, length), buf = new Uint8Array(bufSize), totBytesRead = 0;
+    for (; totBytesRead < length; ) {
+      let remaining = length - totBytesRead, bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
+      if (bytesRead < 0)
+        return bytesRead;
+      totBytesRead += bytesRead;
+    }
+    return totBytesRead;
+  }
+  abort() {
+    return this.streamReader.abort();
+  }
+  async close() {
+    return this.streamReader.close();
+  }
+  supportsRandomAccess() {
+    return !1;
+  }
+};
+
+// node_modules/strtok3/lib/BufferTokenizer.js
+var BufferTokenizer = class extends AbstractTokenizer {
+  /**
+   * Construct BufferTokenizer
+   * @param uint8Array - Uint8Array to tokenize
+   * @param options Tokenizer options
+   */
+  constructor(uint8Array, options) {
+    super(options), this.uint8Array = uint8Array, this.fileInfo = { ...options?.fileInfo ?? {}, size: uint8Array.length };
+  }
+  /**
+   * Read buffer from tokenizer
+   * @param uint8Array - Uint8Array to tokenize
+   * @param options - Read behaviour options
+   * @returns {Promise<number>}
+   */
+  async readBuffer(uint8Array, options) {
+    options?.position && (this.position = options.position);
+    let bytesRead = await this.peekBuffer(uint8Array, options);
+    return this.position += bytesRead, bytesRead;
+  }
+  /**
+   * Peek (read ahead) buffer from tokenizer
+   * @param uint8Array
+   * @param options - Read behaviour options
+   * @returns {Promise<number>}
+   */
+  async peekBuffer(uint8Array, options) {
+    let normOptions = this.normalizeOptions(uint8Array, options), bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
+    if (!normOptions.mayBeLess && bytes2read < normOptions.length)
+      throw new EndOfStreamError();
+    return uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read)), bytes2read;
+  }
+  close() {
+    return super.close();
+  }
+  supportsRandomAccess() {
+    return !0;
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+};
+
+// node_modules/strtok3/lib/BlobTokenizer.js
+var BlobTokenizer = class extends AbstractTokenizer {
+  /**
+   * Construct BufferTokenizer
+   * @param blob - Uint8Array to tokenize
+   * @param options Tokenizer options
+   */
+  constructor(blob, options) {
+    super(options), this.blob = blob, this.fileInfo = { ...options?.fileInfo ?? {}, size: blob.size, mimeType: blob.type };
+  }
+  /**
+   * Read buffer from tokenizer
+   * @param uint8Array - Uint8Array to tokenize
+   * @param options - Read behaviour options
+   * @returns {Promise<number>}
+   */
+  async readBuffer(uint8Array, options) {
+    options?.position && (this.position = options.position);
+    let bytesRead = await this.peekBuffer(uint8Array, options);
+    return this.position += bytesRead, bytesRead;
+  }
+  /**
+   * Peek (read ahead) buffer from tokenizer
+   * @param buffer
+   * @param options - Read behaviour options
+   * @returns {Promise<number>}
+   */
+  async peekBuffer(buffer, options) {
+    let normOptions = this.normalizeOptions(buffer, options), bytes2read = Math.min(this.blob.size - normOptions.position, normOptions.length);
+    if (!normOptions.mayBeLess && bytes2read < normOptions.length)
+      throw new EndOfStreamError();
+    let arrayBuffer = await this.blob.slice(normOptions.position, normOptions.position + bytes2read).arrayBuffer();
+    return buffer.set(new Uint8Array(arrayBuffer)), bytes2read;
+  }
+  close() {
+    return super.close();
+  }
+  supportsRandomAccess() {
+    return !0;
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+};
+
+// node_modules/strtok3/lib/core.js
+function fromStream(stream, options) {
+  let streamReader = new StreamReader(stream), _options = options ?? {}, chainedClose = _options.onClose;
+  return _options.onClose = async () => {
+    if (await streamReader.close(), chainedClose)
+      return chainedClose();
+  }, new ReadStreamTokenizer(streamReader, _options);
+}
+function fromWebStream(webStream, options) {
+  let webStreamReader = makeWebStreamReader(webStream), _options = options ?? {}, chainedClose = _options.onClose;
+  return _options.onClose = async () => {
+    if (await webStreamReader.close(), chainedClose)
+      return chainedClose();
+  }, new ReadStreamTokenizer(webStreamReader, _options);
+}
+function fromBuffer(uint8Array, options) {
+  return new BufferTokenizer(uint8Array, options);
+}
+function fromBlob(blob, options) {
+  return new BlobTokenizer(blob, options);
+}
+
+// node_modules/strtok3/lib/index.js
+import { stat as fsStat } from "node:fs/promises";
+
+// node_modules/strtok3/lib/FileTokenizer.js
+import { open as fsOpen } from "node:fs/promises";
+var FileTokenizer = class _FileTokenizer extends AbstractTokenizer {
+  /**
+   * Create tokenizer from provided file path
+   * @param sourceFilePath File path
+   */
+  static async fromFile(sourceFilePath) {
+    let fileHandle = await fsOpen(sourceFilePath, "r"), stat = await fileHandle.stat();
+    return new _FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat.size } });
+  }
+  constructor(fileHandle, options) {
+    super(options), this.fileHandle = fileHandle, this.fileInfo = options.fileInfo;
+  }
+  /**
+   * Read buffer from file
+   * @param uint8Array - Uint8Array to write result to
+   * @param options - Read behaviour options
+   * @returns Promise number of bytes read
+   */
+  async readBuffer(uint8Array, options) {
+    let normOptions = this.normalizeOptions(uint8Array, options);
+    if (this.position = normOptions.position, normOptions.length === 0)
+      return 0;
+    let res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
+    if (this.position += res.bytesRead, res.bytesRead < normOptions.length && (!options || !options.mayBeLess))
+      throw new EndOfStreamError();
+    return res.bytesRead;
+  }
+  /**
+   * Peek buffer from file
+   * @param uint8Array - Uint8Array (or Buffer) to write data to
+   * @param options - Read behaviour options
+   * @returns Promise number of bytes read
+   */
+  async peekBuffer(uint8Array, options) {
+    let normOptions = this.normalizeOptions(uint8Array, options), res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
+    if (!normOptions.mayBeLess && res.bytesRead < normOptions.length)
+      throw new EndOfStreamError();
+    return res.bytesRead;
+  }
+  async close() {
+    return await this.fileHandle.close(), super.close();
+  }
+  setPosition(position) {
+    this.position = position;
+  }
+  supportsRandomAccess() {
+    return !0;
+  }
+};
+
+// node_modules/strtok3/lib/index.js
+async function fromStream2(stream, options) {
+  let rst = fromStream(stream, options);
+  if (stream.path) {
+    let stat = await fsStat(stream.path);
+    rst.fileInfo.path = stream.path, rst.fileInfo.size = stat.size;
+  }
+  return rst;
+}
+var fromFile = FileTokenizer.fromFile;
+
+export {
+  EndOfStreamError,
+  fromWebStream,
+  fromBuffer,
+  fromBlob,
+  fromStream2 as fromStream,
+  fromFile
+};

package/dist/chunks/chunk-HPVFJYXR.mjs

@@ -0,0 +1,112 @@
+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/executor/environment.ts
+var EnvironmentResolver = class {
+  systemVars;
+  eventVars = {};
+  exportedVars = {};
+  /** Command-scoped vars from `VAR=val cmd` prefixes (see withOverlay) */
+  overlayVars = {};
+  /** Exit code of the last executed command, exposed as $? */
+  lastExitCode = 0;
+  workspace;
+  constructor(config, workspace) {
+    this.workspace = workspace, this.systemVars = {
+      AGENT_NAME: config.name ?? "",
+      AGENT_STATE: config.state ?? "active",
+      PWD: "/"
+    };
+  }
+  /** Set event context variables from AdfEventDispatch */
+  setTriggerContext(dispatch) {
+    this.eventVars = {};
+    let { event } = dispatch;
+    if (this.eventVars.EVENT_TYPE = event.type, event.type === "inbox" && event.data) {
+      let d = event.data;
+      this.eventVars.MSG_ID = d.message.id, this.eventVars.MSG_FROM = d.message.from, d.message.source && (this.eventVars.MSG_CHANNEL = d.message.source);
+    } else if (event.type === "timer" && event.data) {
+      let d = event.data;
+      this.eventVars.TIMER_ID = String(d.timer.id), d.timer.payload && (this.eventVars.TIMER_PAYLOAD = d.timer.payload);
+    } else if (event.type === "task_create" && event.data) {
+      let d = event.data;
+      this.eventVars.TASK_ID = d.task.id, this.eventVars.TASK_TOOL = d.task.tool, this.eventVars.TASK_STATUS = d.task.status;
+    } else if (event.type === "task_complete" && event.data) {
+      let d = event.data;
+      this.eventVars.TASK_ID = d.task.id, this.eventVars.TASK_STATUS = d.task.status;
+    } else if (event.type === "tool_call" && event.data) {
+      let d = event.data;
+      this.eventVars.TASK_ID = "";
+    } else if (event.type === "file_change" && event.data) {
+      let d = event.data;
+      this.eventVars.CHANGED_PATH = d.path;
+    } else if (event.type === "llm_call" && event.data) {
+      let d = event.data;
+      this.eventVars.LLM_PROVIDER = d.provider, this.eventVars.LLM_MODEL = d.model, this.eventVars.LLM_SOURCE = d.source, this.eventVars.LLM_INPUT_TOKENS = String(d.input_tokens), this.eventVars.LLM_OUTPUT_TOKENS = String(d.output_tokens), this.eventVars.LLM_DURATION_MS = String(d.duration_ms), this.eventVars.LLM_STOP_REASON = d.stop_reason, d.cost_usd !== void 0 && (this.eventVars.LLM_COST_USD = String(d.cost_usd));
+    }
+  }
+  /** Set a variable via export KEY=VALUE */
+  export(key, value) {
+    this.exportedVars[key] = value;
+  }
+  /** Record the exit code of the last executed command ($?) */
+  setLastExitCode(code) {
+    this.lastExitCode = code;
+  }
+  /** Create a command-scoped view where `vars` shadow everything else
+   *  (`VAR=val cmd`). The view shares all other state with this resolver. */
+  withOverlay(vars) {
+    let child = Object.create(this);
+    return child.overlayVars = { ...this.overlayVars, ...vars }, child;
+  }
+  /** Whether a variable is set — distinct from empty (`${VAR-def}` semantics) */
+  has(name) {
+    return name === "?" || name in this.overlayVars || name in this.exportedVars || name in this.eventVars || name in this.systemVars ? !0 : this.resolve(name) !== "";
+  }
+  /** Resolve a variable name to its value */
+  resolve(name) {
+    if (name === "?") return String(this.lastExitCode);
+    if (name in this.overlayVars) return this.overlayVars[name];
+    if (name in this.exportedVars) return this.exportedVars[name];
+    if (name in this.eventVars) return this.eventVars[name];
+    if (name in this.systemVars) return this.systemVars[name];
+    if (name === "AGENT_DID")
+      try {
+        return this.workspace.getDid?.() ?? this.workspace.getIdentity("did") ?? "";
+      } catch {
+        return "";
+      }
+    try {
+      let val = this.workspace.getIdentity(name.toLowerCase());
+      if (val) return val;
+    } catch {
+    }
+    return "";
+  }
+  /** List all environment variables (for `env` command). Redacts sensitive values. */
+  listAll() {
+    let result = [];
+    for (let [k, v] of Object.entries(this.systemVars))
+      result.push({ key: k, value: v, source: "system" });
+    for (let [k, v] of Object.entries(this.eventVars))
+      result.push({ key: k, value: v, source: "event" });
+    for (let [k, v] of Object.entries(this.exportedVars))
+      result.push({ key: k, value: v, source: "export" });
+    for (let [k, v] of Object.entries(this.overlayVars))
+      result.push({ key: k, value: v, source: "command" });
+    return result;
+  }
+};
+function resolveWithDefault(env, name, op, word) {
+  let value = env.resolve(name);
+  return op === void 0 ? value : op === ":-" ? value !== "" ? value : word ?? "" : op === "-" ? env.has(name) ? value : word ?? "" : value;
+}
+
+export {
+  EnvironmentResolver,
+  resolveWithDefault
+};