mlld/dist/exec-invocation-BKHC2VUW.mjs

mlld: a modular prompt scripting language

import { prepareValueForShadow } from './chunk-3BKXIDNI.mjs';
import { interpolate, AutoUnwrapManager, extractSection } from './chunk-FYMHT7UG.mjs';
import { InterpolationContext } from './chunk-RZIZRJBS.mjs';
import { logger } from './chunk-XGMRAGIT.mjs';
import { MlldInterpreterError } from './chunk-YMCO2JI3.mjs';
import { isTemplateExecutable, isCommandExecutable, isCodeExecutable, isCommandRefExecutable, isSectionExecutable, isResolverExecutable } from './chunk-6BOVVHHZ.mjs';
import { isExecutableVariable } from './chunk-V5L6FBQT.mjs';
import { createObjectVariable, createArrayVariable, createPrimitiveVariable, createSimpleTextVariable } from './chunk-TU56GBG3.mjs';
import { isLoadContentResultArray, isLoadContentResult } from './chunk-444AWGDO.mjs';
import { __name, __publicField } from './chunk-OMKLS24H.mjs';

// interpreter/eval/with-clause.ts
async function applyWithClause(input, withClause, env) {
  let result = input;
  if (withClause.pipeline && withClause.pipeline.length > 0) {
    const format = withClause.format;
    const { executePipeline } = await import('./pipeline-HBV22AHW.mjs');
    result = await executePipeline(result, withClause.pipeline, env, void 0, format);
  }
  if (withClause.trust) {
    validateTrust(result, withClause.trust);
  }
  if (withClause.needs) {
    await checkDependencies(withClause.needs, env);
  }
  return {
    value: result,
    env,
    stdout: result,
    stderr: "",
    exitCode: 0
  };
}
__name(applyWithClause, "applyWithClause");
function validateTrust(result, trustLevel) {
  if (trustLevel === "never") {
    throw new MlldInterpreterError('Trust level "never" not yet implemented');
  }
}
__name(validateTrust, "validateTrust");
async function checkDependencies(needs, env) {
  if (needs.file) {
    const exists = await env.fileSystem.exists(needs.file);
    if (!exists) {
      throw new MlldInterpreterError(`Required file not found: ${needs.file}`);
    }
  }
}
__name(checkDependencies, "checkDependencies");

// interpreter/eval/exec-invocation.ts
var _a;
var SimpleMetadataShelf = (_a = class {
  constructor() {
    __publicField(this, "shelf", /* @__PURE__ */ new Map());
  }
  storeMetadata(value) {
    if (isLoadContentResultArray(value)) {
      for (const item of value) {
        if (isLoadContentResult(item)) {
          this.shelf.set(item.content, item);
        }
      }
    } else if (isLoadContentResult(value)) {
      this.shelf.set(value.content, value);
    }
  }
  restoreMetadata(value) {
    if (!Array.isArray(value)) return value;
    const restored = [];
    let hasRestorable = false;
    for (const item of value) {
      if (typeof item === "string" && this.shelf.has(item)) {
        restored.push(this.shelf.get(item));
        hasRestorable = true;
      } else {
        restored.push(item);
      }
    }
    return hasRestorable ? restored : value;
  }
  clear() {
    this.shelf.clear();
  }
}, __name(_a, "SimpleMetadataShelf"), _a);
var metadataShelf = new SimpleMetadataShelf();
async function evaluateExecInvocation(node, env) {
  if (process.env.DEBUG_WHEN || process.env.DEBUG_EXEC) {
    logger.debug("evaluateExecInvocation called with:", {
      commandRef: node.commandRef
    });
  }
  let commandName;
  let args = [];
  if (!node.commandRef && node.name) {
    commandName = node.name;
    args = node.arguments || [];
  } else if (node.commandRef) {
    if (node.commandRef.name) {
      commandName = node.commandRef.name;
      args = node.commandRef.args || [];
    } else if (typeof node.commandRef.identifier === "string") {
      commandName = node.commandRef.identifier;
      args = node.commandRef.args || [];
    } else if (Array.isArray(node.commandRef.identifier) && node.commandRef.identifier.length > 0) {
      const identifierNode = node.commandRef.identifier[0];
      if (identifierNode.type === "VariableReference" && identifierNode.identifier) {
        commandName = identifierNode.identifier;
      } else if (identifierNode.type === "Text" && identifierNode.content) {
        commandName = identifierNode.content;
      } else {
        throw new Error("Unable to extract command name from identifier array");
      }
      args = node.commandRef.args || [];
    } else {
      throw new Error("CommandReference missing both name and identifier");
    }
  } else {
    throw new Error("ExecInvocation node missing both commandRef and name");
  }
  if (!commandName) {
    throw new MlldInterpreterError("ExecInvocation has no command identifier");
  }
  let variable;
  const commandRefWithObject = node.commandRef;
  if (node.commandRef && commandRefWithObject.objectReference) {
    const objectRef = commandRefWithObject.objectReference;
    const objectVar = env.getVariable(objectRef.identifier);
    if (!objectVar) {
      throw new MlldInterpreterError(`Object not found: ${objectRef.identifier}`);
    }
    const { extractVariableValue } = await import('./variable-resolution-SVHB4DCD.mjs');
    const objectValue = await extractVariableValue(objectVar, env);
    if (process.env.DEBUG_EXEC) {
      logger.debug("Object reference in exec invocation", {
        objectRef: objectRef.identifier,
        objectVarType: objectVar.type,
        objectVarValue: typeof objectVar.value,
        objectVarIsComplex: objectVar.isComplex,
        objectValueType: typeof objectValue,
        isString: typeof objectValue === "string",
        objectKeys: typeof objectValue === "object" && objectValue !== null ? Object.keys(objectValue) : "not-object",
        objectValue: typeof objectValue === "object" && objectValue !== null ? JSON.stringify(objectValue, null, 2).substring(0, 500) : objectValue
      });
    }
    if (objectRef.fields && objectRef.fields.length > 0) {
      let currentValue = objectValue;
      for (const field of objectRef.fields) {
        if (process.env.DEBUG_EXEC) {
          logger.debug("Accessing field", {
            fieldType: field.type,
            fieldValue: field.value,
            currentValueType: typeof currentValue,
            currentValueKeys: typeof currentValue === "object" && currentValue !== null ? Object.keys(currentValue) : "not-object"
          });
        }
        if (typeof currentValue === "object" && currentValue !== null) {
          currentValue = currentValue[field.value];
          if (process.env.DEBUG_EXEC) {
            logger.debug("Field access result", {
              fieldValue: field.value,
              resultType: typeof currentValue,
              resultKeys: typeof currentValue === "object" && currentValue !== null ? Object.keys(currentValue) : "not-object"
            });
          }
        } else {
          throw new MlldInterpreterError(`Cannot access field ${field.value} on non-object`);
        }
      }
      if (typeof currentValue === "object" && currentValue !== null) {
        const fieldValue = currentValue[commandName];
        variable = fieldValue;
      }
    } else {
      if (typeof objectValue === "object" && objectValue !== null) {
        let fieldValue;
        if (objectValue.type === "object" && objectValue.properties) {
          fieldValue = objectValue.properties[commandName];
        } else {
          fieldValue = objectValue[commandName];
        }
        variable = fieldValue;
      }
    }
    if (!variable) {
      throw new MlldInterpreterError(`Method not found: ${commandName} on ${objectRef.identifier}`);
    }
    if (typeof variable === "object" && variable !== null && "__executable" in variable && variable.__executable) {
      let metadata = variable.metadata || {};
      if (metadata.capturedShadowEnvs && typeof metadata.capturedShadowEnvs === "object") {
        const needsDeserialization = Object.entries(metadata.capturedShadowEnvs).some(([lang, env2]) => env2 && !(env2 instanceof Map));
        if (needsDeserialization) {
          metadata = {
            ...metadata,
            capturedShadowEnvs: deserializeShadowEnvs(metadata.capturedShadowEnvs)
          };
        }
      }
      if (process.env.DEBUG_MODULE_EXPORT || process.env.DEBUG_EXEC) {
        console.error("[DEBUG] Converting __executable object to ExecutableVariable:", {
          commandName,
          hasMetadata: !!metadata,
          hasCapturedEnvs: !!metadata.capturedShadowEnvs,
          metadata
        });
      }
      const { createExecutableVariable } = await import('./VariableFactories-BQT4D3YO.mjs');
      variable = createExecutableVariable(commandName, "command", "", variable.paramNames || [], void 0, {
        directive: "exe",
        syntax: "braces",
        hasInterpolation: false,
        isMultiLine: false
      }, {
        executableDef: variable.executableDef,
        ...metadata
      });
    }
  } else {
    variable = env.getVariable(commandName);
    if (!variable) {
      throw new MlldInterpreterError(`Command not found: ${commandName}`);
    }
  }
  if (!isExecutableVariable(variable)) {
    throw new MlldInterpreterError(`Variable ${commandName} is not executable (type: ${variable.type})`);
  }
  if (variable.metadata?.isBuiltinTransformer && variable.metadata?.transformerImplementation) {
    if (commandName === "typeof" || commandName === "TYPEOF") {
      if (args.length > 0) {
        const arg = args[0];
        if (arg && typeof arg === "object" && "type" in arg && arg.type === "VariableReference") {
          const varRef = arg;
          const varName = varRef.identifier;
          const varObj = env.getVariable(varName);
          if (varObj) {
            let typeInfo = varObj.type;
            if (varObj.type === "simple-text" && "subtype" in varObj) {
              const subtype = varObj.subtype;
              if (subtype && subtype !== "simple" && subtype !== "interpolated-text") {
                typeInfo = subtype;
              }
            } else if (varObj.type === "primitive" && "primitiveType" in varObj) {
              typeInfo = `primitive (${varObj.primitiveType})`;
            } else if (varObj.type === "object") {
              const objValue = varObj.value;
              if (objValue && typeof objValue === "object") {
                const keys = Object.keys(objValue);
                typeInfo = `object (${keys.length} properties)`;
              }
            } else if (varObj.type === "array") {
              const arrValue = varObj.value;
              if (Array.isArray(arrValue)) {
                typeInfo = `array (${arrValue.length} items)`;
              }
            } else if (varObj.type === "executable") {
              const execDef = varObj.metadata?.executableDef;
              if (execDef && "type" in execDef) {
                typeInfo = `executable (${execDef.type})`;
              }
            }
            if (varObj.source?.directive) {
              typeInfo += ` [from /${varObj.source.directive}]`;
            }
            const result3 = await variable.metadata.transformerImplementation(`__MLLD_VARIABLE_OBJECT__:${typeInfo}`);
            if (node.withClause) {
              return applyWithClause(String(result3), node.withClause, env);
            }
            return {
              value: String(result3),
              env,
              stdout: String(result3),
              stderr: "",
              exitCode: 0
            };
          }
        }
      }
    }
    let inputValue = "";
    if (args.length > 0) {
      const arg = args[0];
      if (typeof arg === "string") {
        inputValue = arg;
      } else if (arg && typeof arg === "object") {
        inputValue = await interpolate([
          arg
        ], env);
      } else {
        inputValue = String(arg);
      }
    }
    const result2 = await variable.metadata.transformerImplementation(inputValue);
    if (node.withClause) {
      return applyWithClause(String(result2), node.withClause, env);
    }
    return {
      value: String(result2),
      env,
      stdout: String(result2),
      stderr: "",
      exitCode: 0
    };
  }
  const definition = variable.metadata?.executableDef;
  if (!definition) {
    throw new MlldInterpreterError(`Executable ${commandName} has no definition in metadata`);
  }
  const execEnv = env.createChild();
  const params = definition.paramNames || [];
  const evaluatedArgStrings = [];
  const evaluatedArgs = [];
  for (const arg of args) {
    let argValue;
    let argValueAny;
    if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
      argValue = String(arg);
      argValueAny = arg;
    } else if (arg && typeof arg === "object" && "type" in arg) {
      switch (arg.type) {
        case "object":
          const { evaluateDataValue } = await import('./data-value-evaluator-UFIUOP64.mjs');
          argValueAny = await evaluateDataValue(arg, env);
          argValue = JSON.stringify(argValueAny);
          break;
        case "array":
          const { evaluateDataValue: evalArray } = await import('./data-value-evaluator-UFIUOP64.mjs');
          argValueAny = await evalArray(arg, env);
          argValue = JSON.stringify(argValueAny);
          break;
        case "VariableReference":
          const varRef = arg;
          const varName = varRef.identifier;
          const variable2 = env.getVariable(varName);
          if (variable2) {
            let value = variable2.value;
            if (varRef.fields && varRef.fields.length > 0) {
              for (const field of varRef.fields) {
                if (value && typeof value === "object" && (field.type === "field" || field.type === "numericField")) {
                  value = value[field.value];
                } else if (Array.isArray(value) && (field.type === "index" || field.type === "arrayIndex")) {
                  const index = parseInt(field.value, 10);
                  value = isNaN(index) ? void 0 : value[index];
                } else {
                  value = void 0;
                  break;
                }
              }
            }
            argValueAny = value;
            if (value === void 0) {
              argValue = "undefined";
            } else if (typeof value === "object" && value !== null) {
              try {
                argValue = JSON.stringify(value);
              } catch (e) {
                argValue = String(value);
              }
            } else {
              argValue = String(value);
            }
          } else {
            argValue = await interpolate([
              arg
            ], env, InterpolationContext.Default);
            argValueAny = argValue;
          }
          break;
        case "ExecInvocation":
        case "Text":
        default:
          argValue = await interpolate([
            arg
          ], env, InterpolationContext.Default);
          try {
            argValueAny = JSON.parse(argValue);
          } catch {
            argValueAny = argValue;
          }
          break;
      }
    } else {
      argValue = String(arg);
      argValueAny = arg;
    }
    evaluatedArgStrings.push(argValue);
    evaluatedArgs.push(argValueAny);
  }
  const originalVariables = [];
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    if (arg && typeof arg === "object" && "type" in arg && arg.type === "VariableReference") {
      const varRef = arg;
      const varName = varRef.identifier;
      const variable2 = env.getVariable(varName);
      if (variable2 && !varRef.fields) {
        originalVariables[i] = variable2;
        if (process.env.MLLD_DEBUG === "true") {
          const subtype = variable2.type === "primitive" && "primitiveType" in variable2 ? variable2.primitiveType : variable2.subtype;
          logger.debug(`Preserving original Variable for arg ${i}:`, {
            varName,
            variableType: variable2.type,
            variableSubtype: subtype,
            isPrimitive: typeof variable2.value !== "object" || variable2.value === null
          });
        }
      }
    }
  }
  for (let i = 0; i < params.length; i++) {
    const paramName = params[i];
    const argValue = evaluatedArgs[i];
    const argStringValue = evaluatedArgStrings[i];
    if (argValue !== void 0) {
      let paramVar;
      const originalVar = originalVariables[i];
      if (originalVar) {
        paramVar = {
          ...originalVar,
          name: paramName,
          metadata: {
            ...originalVar.metadata,
            isSystem: true,
            isParameter: true
          }
        };
        if (process.env.MLLD_DEBUG === "true") {
          const subtype = paramVar.type === "primitive" && "primitiveType" in paramVar ? paramVar.primitiveType : paramVar.subtype;
          logger.debug(`Using original Variable for param ${paramName}:`, {
            type: paramVar.type,
            subtype,
            hasMetadata: !!paramVar.metadata
          });
        }
      } else if (typeof argValue === "object" && argValue !== null && !Array.isArray(argValue)) {
        paramVar = createObjectVariable(paramName, argValue, true, {
          directive: "var",
          syntax: "object",
          hasInterpolation: false,
          isMultiLine: false
        }, {
          isSystem: true,
          isParameter: true
        });
      } else if (Array.isArray(argValue)) {
        paramVar = createArrayVariable(paramName, argValue, true, {
          directive: "var",
          syntax: "array",
          hasInterpolation: false,
          isMultiLine: false
        }, {
          isSystem: true,
          isParameter: true
        });
      } else {
        if (typeof argValue === "number" || typeof argValue === "boolean" || argValue === null) {
          paramVar = createPrimitiveVariable(paramName, argValue, {
            directive: "var",
            syntax: "literal",
            hasInterpolation: false,
            isMultiLine: false
          }, {
            isSystem: true,
            isParameter: true
          });
        } else {
          paramVar = createSimpleTextVariable(paramName, argStringValue, {
            directive: "var",
            syntax: "quoted",
            hasInterpolation: false,
            isMultiLine: false
          }, {
            isSystem: true,
            isParameter: true
          });
        }
      }
      execEnv.setParameterVariable(paramName, paramVar);
    }
  }
  let result;
  if (isTemplateExecutable(definition)) {
    result = await interpolate(definition.template, execEnv);
  } else if (isCommandExecutable(definition)) {
    const command = await interpolate(definition.commandTemplate, execEnv, InterpolationContext.ShellCommand);
    if (process.env.DEBUG_WHEN || process.env.DEBUG_EXEC) {
      logger.debug("Executing command", {
        command,
        commandTemplate: definition.commandTemplate
      });
    }
    const envVars = {};
    for (let i = 0; i < params.length; i++) {
      const paramName = params[i];
      const paramVar = execEnv.getVariable(paramName);
      if (paramVar && typeof paramVar.value === "object" && paramVar.value !== null) {
        try {
          envVars[paramName] = JSON.stringify(paramVar.value);
        } catch (e) {
          envVars[paramName] = evaluatedArgStrings[i];
        }
      } else {
        envVars[paramName] = evaluatedArgStrings[i];
      }
    }
    const commandOutput = await execEnv.executeCommand(command, {
      env: envVars
    });
    if (typeof commandOutput === "string" && commandOutput.trim()) {
      const trimmed = commandOutput.trim();
      if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
        try {
          result = JSON.parse(trimmed);
        } catch {
          result = commandOutput;
        }
      } else {
        result = commandOutput;
      }
    } else {
      result = commandOutput;
    }
  } else if (isCodeExecutable(definition)) {
    if (definition.language === "mlld-when") {
      const whenExprNode = definition.codeTemplate[0];
      if (!whenExprNode || whenExprNode.type !== "WhenExpression") {
        throw new MlldInterpreterError("mlld-when executable missing WhenExpression node");
      }
      const { evaluateWhenExpression } = await import('./when-expression-O2PEVPZS.mjs');
      const whenResult = await evaluateWhenExpression(whenExprNode, execEnv);
      result = whenResult.value;
    } else if (definition.language === "mlld-for") {
      const forExprNode = definition.codeTemplate[0];
      if (!forExprNode || forExprNode.type !== "ForExpression") {
        throw new MlldInterpreterError("mlld-for executable missing ForExpression node");
      }
      const { evaluateForExpression } = await import('./for-CP5DH4KK.mjs');
      result = await evaluateForExpression(forExprNode, execEnv);
    } else {
      let code;
      if (definition.language === "bash" || definition.language === "sh") {
        if (Array.isArray(definition.codeTemplate)) {
          code = definition.codeTemplate.map((node2) => {
            if (typeof node2 === "string") return node2;
            if (node2 && typeof node2 === "object" && "content" in node2) return node2.content || "";
            return "";
          }).join("");
        } else if (typeof definition.codeTemplate === "string") {
          code = definition.codeTemplate;
        } else {
          code = "";
        }
      } else {
        code = await interpolate(definition.codeTemplate, execEnv);
      }
      const { ASTEvaluator } = await import('./ast-evaluator-WZNEUUA2.mjs');
      const codeParams = {};
      const variableMetadata = {};
      for (let i = 0; i < params.length; i++) {
        const paramName = params[i];
        const paramVar = execEnv.getVariable(paramName);
        if (process.env.MLLD_DEBUG === "true") {
          logger.debug("Checking parameter:", {
            paramName,
            hasParamVar: !!paramVar,
            paramVarType: paramVar?.type,
            isPipelineInput: paramVar?.type === "pipeline-input"
          });
        }
        if (paramVar && paramVar.type === "pipeline-input") {
          codeParams[paramName] = paramVar.value;
        } else if (paramVar) {
          if (definition.language === "bash" || definition.language === "sh") {
            codeParams[paramName] = prepareValueForShadow(paramVar);
          } else {
            if (paramVar.isComplex && paramVar.value && typeof paramVar.value === "object" && "type" in paramVar.value) {
              const { extractVariableValue: extractVal } = await import('./variable-resolution-SVHB4DCD.mjs');
              const resolvedValue = await extractVal(paramVar, execEnv);
              const resolvedVar = {
                ...paramVar,
                value: resolvedValue,
                isComplex: false
              };
              codeParams[paramName] = prepareValueForShadow(resolvedVar);
            } else {
              metadataShelf.storeMetadata(paramVar.value);
              const unwrappedValue = AutoUnwrapManager.unwrap(paramVar.value);
              if (unwrappedValue !== paramVar.value) {
                const unwrappedVar = {
                  ...paramVar,
                  value: unwrappedValue,
                  // Update type based on unwrapped value
                  type: Array.isArray(unwrappedValue) ? "array" : "text"
                };
                codeParams[paramName] = prepareValueForShadow(unwrappedVar);
              } else {
                codeParams[paramName] = prepareValueForShadow(paramVar);
              }
            }
          }
          if (definition.language !== "bash" && definition.language !== "sh" && (paramVar.value === null || typeof paramVar.value !== "object")) {
            const subtype = paramVar.type === "primitive" && "primitiveType" in paramVar ? paramVar.primitiveType : paramVar.subtype;
            variableMetadata[paramName] = {
              type: paramVar.type,
              subtype,
              metadata: paramVar.metadata,
              isVariable: true
            };
          }
          if (process.env.DEBUG_EXEC || process.env.MLLD_DEBUG === "true") {
            const subtype = paramVar.type === "primitive" && "primitiveType" in paramVar ? paramVar.primitiveType : paramVar.subtype;
            logger.debug(`Variable passing for ${paramName}:`, {
              variableType: paramVar.type,
              variableSubtype: subtype,
              hasMetadata: !!paramVar.metadata,
              isPrimitive: paramVar.value === null || typeof paramVar.value !== "object",
              language: definition.language
            });
          }
        } else {
          const argValue = evaluatedArgs[i];
          codeParams[paramName] = await ASTEvaluator.evaluateToRuntime(argValue, execEnv);
          if (process.env.DEBUG_EXEC) {
            logger.debug(`Code parameter ${paramName}:`, {
              argValue,
              type: typeof argValue,
              isNumber: typeof argValue === "number",
              evaluatedArgs_i: evaluatedArgs[i],
              evaluatedArgStrings_i: evaluatedArgStrings[i]
            });
          }
        }
      }
      const capturedEnvs = variable.metadata?.capturedShadowEnvs;
      if (capturedEnvs && (definition.language === "js" || definition.language === "javascript" || definition.language === "node" || definition.language === "nodejs")) {
        codeParams.__capturedShadowEnvs = capturedEnvs;
        if (process.env.DEBUG_MODULE_EXPORT || process.env.DEBUG_EXEC) {
          console.error("[DEBUG] exec-invocation passing shadow envs:", {
            commandName,
            hasCapturedEnvs: !!capturedEnvs,
            capturedEnvs,
            language: definition.language
          });
        }
      }
      const codeResult = await execEnv.executeCode(code, definition.language || "javascript", codeParams, Object.keys(variableMetadata).length > 0 ? variableMetadata : void 0);
      let processedResult;
      if (typeof codeResult === "string" && (codeResult.startsWith('"') || codeResult.startsWith("{") || codeResult.startsWith("[") || codeResult === "null" || codeResult === "true" || codeResult === "false" || /^-?\d+(\.\d+)?$/.test(codeResult))) {
        try {
          const parsed = JSON.parse(codeResult);
          processedResult = parsed;
        } catch {
          processedResult = codeResult;
        }
      } else {
        processedResult = codeResult;
      }
      result = metadataShelf.restoreMetadata(processedResult);
      metadataShelf.clear();
    }
  } else if (isCommandRefExecutable(definition)) {
    const refName = definition.commandRef;
    if (!refName) {
      throw new MlldInterpreterError(`Command reference ${commandName} has no target command`);
    }
    const refCommand = env.getVariable(refName);
    if (!refCommand) {
      throw new MlldInterpreterError(`Referenced command not found: ${refName}`);
    }
    const refInvocation = {
      commandRef: {
        identifier: refName,
        args: evaluatedArgs.map((arg) => ({
          type: "Text",
          content: arg
        }))
      }
    };
    const refResult = await evaluateExecInvocation(refInvocation, env);
    result = refResult.value;
  } else if (isSectionExecutable(definition)) {
    const filePath = await interpolate(definition.pathTemplate, execEnv);
    const sectionName = await interpolate(definition.sectionTemplate, execEnv);
    const fileContent = await execEnv.readFile(filePath);
    const llmxmlInstance = env.getLlmxml();
    let sectionContent;
    try {
      const titleWithoutHash = sectionName.replace(/^#+\s*/, "");
      sectionContent = await llmxmlInstance.getSection(fileContent, titleWithoutHash, {
        includeNested: true
      });
    } catch (error) {
      sectionContent = extractSection(fileContent, sectionName);
    }
    if (definition.renameTemplate) {
      const newTitle = await interpolate(definition.renameTemplate, execEnv);
      const lines = sectionContent.split("\n");
      if (lines.length > 0 && lines[0].match(/^#+\s/)) {
        const newTitleTrimmed = newTitle.trim();
        const newHeadingMatch = newTitleTrimmed.match(/^(#+)(\s+(.*))?$/);
        if (newHeadingMatch) {
          if (!newHeadingMatch[3]) {
            const originalText = lines[0].replace(/^#+\s*/, "");
            lines[0] = `${newHeadingMatch[1]} ${originalText}`;
          } else {
            lines[0] = newTitleTrimmed;
          }
        } else {
          const originalLevel = lines[0].match(/^#+/)?.[0] || "#";
          lines[0] = `${originalLevel} ${newTitleTrimmed}`;
        }
        sectionContent = lines.join("\n");
      }
    }
    result = sectionContent;
  } else if (isResolverExecutable(definition)) {
    let resolverPath = definition.resolverPath;
    for (let i = 0; i < params.length; i++) {
      const paramName = params[i];
      const argValue = evaluatedArgs[i];
      if (argValue !== void 0) {
        resolverPath = resolverPath.replace(new RegExp(`@${paramName}\\b`, "g"), argValue);
      }
    }
    let payload = void 0;
    if (definition.payloadTemplate) {
      const payloadStr = await interpolate(definition.payloadTemplate, execEnv);
      try {
        payload = JSON.parse(payloadStr);
      } catch {
        payload = payloadStr;
      }
    }
    const resolverManager = env.getResolverManager();
    if (!resolverManager) {
      throw new MlldInterpreterError("Resolver manager not available");
    }
    const resolverResult = await resolverManager.resolve(resolverPath, {
      context: "exec-invocation",
      basePath: env.getBasePath(),
      payload
    });
    if (resolverResult && typeof resolverResult === "object" && "content" in resolverResult) {
      result = resolverResult.content;
    } else if (typeof resolverResult === "string") {
      result = resolverResult;
    } else if (resolverResult && typeof resolverResult === "object") {
      result = JSON.stringify(resolverResult, null, 2);
    } else {
      result = String(resolverResult);
    }
  } else {
    throw new MlldInterpreterError(`Unknown executable type: ${definition.type}`);
  }
  if (node.withClause) {
    const stringResult = typeof result === "string" ? result : JSON.stringify(result);
    return applyWithClause(stringResult, node.withClause, env);
  }
  return {
    value: result,
    env,
    // For stdout, convert the parsed value back to string for backward compatibility
    // but preserve the actual value in the value field for truthiness checks
    stdout: typeof result === "string" ? result : typeof result === "object" && result !== null ? JSON.stringify(result) : String(result),
    stderr: "",
    exitCode: 0
  };
}
__name(evaluateExecInvocation, "evaluateExecInvocation");
function deserializeShadowEnvs(envs) {
  const result = {};
  for (const [lang, shadowObj] of Object.entries(envs)) {
    if (shadowObj && typeof shadowObj === "object") {
      const map = /* @__PURE__ */ new Map();
      for (const [name, func] of Object.entries(shadowObj)) {
        map.set(name, func);
      }
      result[lang] = map;
    }
  }
  return result;
}
__name(deserializeShadowEnvs, "deserializeShadowEnvs");

export { evaluateExecInvocation };
//# sourceMappingURL=exec-invocation-BKHC2VUW.mjs.map
//# sourceMappingURL=exec-invocation-BKHC2VUW.mjs.map