@riotprompt/riotprompt 0.0.11 → 0.0.13

package/dist/cli.cjs

@@ -0,0 +1,1519 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("dotenv/config");
+const commander = require("commander");
+const cardigantime = require("@theunwalked/cardigantime");
+const zod = require("zod");
+const fs$1 = require("fs/promises");
+const path = require("path");
+const crypto = require("crypto");
+require("tiktoken");
+const fastXmlParser = require("fast-xml-parser");
+const OpenAI = require("openai");
+const Anthropic = require("@anthropic-ai/sdk");
+const generativeAi = require("@google/generative-ai");
+const fs = require("fs");
+const glob = require("glob");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace$1 = /* @__PURE__ */ _interopNamespaceDefault(fs$1);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const ConfigSchema = zod.z.object({
+  defaultModel: zod.z.string().default("gpt-4").describe("Default model to use for formatting"),
+  promptsDir: zod.z.string().default(".").describe("Directory containing prompts"),
+  outputDir: zod.z.string().optional().describe("Directory to output formatted prompts")
+});
+const ParametersSchema = zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.array(zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]))]));
+const apply = (text, parameters) => {
+  if (!parameters) {
+    return text;
+  }
+  const trimmedParams = {};
+  Object.keys(parameters).forEach((key) => {
+    trimmedParams[key.trim()] = parameters[key];
+  });
+  return text.replace(/\{\{([^{}]+)\}\}/g, (match, p1) => {
+    const paramKey = p1.trim();
+    const parameter = trimmedParams[paramKey];
+    if (parameter === void 0) {
+      return match;
+    } else if (typeof parameter === "string") {
+      return parameter;
+    } else if (typeof parameter === "number") {
+      return parameter.toString();
+    } else if (typeof parameter === "boolean") {
+      return parameter.toString();
+    } else if (Array.isArray(parameter)) {
+      return parameter.join(", ");
+    } else {
+      return match;
+    }
+  });
+};
+zod.z.object({
+  text: zod.z.string(),
+  weight: zod.z.number().optional()
+});
+const WeightedOptionsSchema = zod.z.object({
+  weight: zod.z.number().optional(),
+  parameters: ParametersSchema.optional()
+});
+const create$6 = (text, options = {}) => {
+  const weightedOptions = WeightedOptionsSchema.parse(options);
+  const parameterizedText = apply(text, weightedOptions.parameters);
+  return {
+    text: parameterizedText,
+    weight: weightedOptions.weight
+  };
+};
+const create$5 = (text, options = {}) => {
+  const weightedOptions = WeightedOptionsSchema.parse(options);
+  return create$6(text, weightedOptions);
+};
+const SectionOptionsSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  weight: zod.z.number().optional(),
+  itemWeight: zod.z.number().optional(),
+  parameters: ParametersSchema.optional().default({})
+});
+const create$4 = (options = {}) => {
+  const items = [];
+  const sectionOptions = SectionOptionsSchema.parse(options);
+  const sectionItemOptions = WeightedOptionsSchema.parse({
+    ...sectionOptions,
+    weight: sectionOptions.itemWeight
+  });
+  const append = (item, options2 = {}) => {
+    let itemOptions = WeightedOptionsSchema.parse(options2);
+    itemOptions = { ...sectionItemOptions, ...itemOptions };
+    if (Array.isArray(item)) {
+      item.forEach((item2) => {
+        append(item2, options2);
+      });
+    } else {
+      if (typeof item === "string") {
+        items.push(create$6(item, itemOptions));
+      } else {
+        items.push(item);
+      }
+    }
+    return section;
+  };
+  const prepend = (item, options2 = {}) => {
+    let itemOptions = WeightedOptionsSchema.parse(options2);
+    itemOptions = { ...sectionItemOptions, ...itemOptions };
+    if (Array.isArray(item)) {
+      item.forEach((item2) => {
+        prepend(item2, options2);
+      });
+    } else {
+      if (typeof item === "string") {
+        items.unshift(create$6(item, itemOptions));
+      } else {
+        items.unshift(item);
+      }
+    }
+    return section;
+  };
+  const insert = (index, item, options2 = {}) => {
+    let itemOptions = WeightedOptionsSchema.parse(options2);
+    itemOptions = { ...sectionItemOptions, ...itemOptions };
+    if (Array.isArray(item)) {
+      item.forEach((item2) => {
+        insert(index, item2, options2);
+      });
+    } else {
+      if (typeof item === "string") {
+        items.splice(index, 0, create$6(item, itemOptions));
+      } else {
+        items.splice(index, 0, item);
+      }
+    }
+    return section;
+  };
+  const remove = (index) => {
+    items.splice(index, 1);
+    return section;
+  };
+  const replace = (index, item, options2 = {}) => {
+    let itemOptions = WeightedOptionsSchema.parse(options2);
+    itemOptions = { ...sectionItemOptions, ...itemOptions };
+    if (typeof item === "string") {
+      items[index] = create$6(item, itemOptions);
+    } else {
+      items[index] = item;
+    }
+    return section;
+  };
+  const add = (item, options2 = {}) => {
+    let itemOptions = WeightedOptionsSchema.parse(options2);
+    itemOptions = { ...sectionItemOptions, ...itemOptions };
+    return append(item, itemOptions);
+  };
+  const toJSON2 = () => {
+    return {
+      title: section.title,
+      items: items.map((item) => {
+        return typeof item === "object" && item !== null && "toJSON" in item && typeof item.toJSON === "function" ? item.toJSON() : item;
+      }),
+      weight: section.weight
+    };
+  };
+  const section = {
+    title: sectionOptions.title,
+    items,
+    weight: sectionOptions.weight,
+    add,
+    append,
+    prepend,
+    insert,
+    remove,
+    replace,
+    toJSON: toJSON2
+  };
+  return section;
+};
+const create$3 = ({
+  persona,
+  instructions,
+  contents,
+  contexts
+}) => {
+  return {
+    persona,
+    instructions,
+    contents,
+    contexts
+  };
+};
+const LIBRARY_NAME = "riotprompt";
+const DEFAULT_IGNORE_PATTERNS = [
+  "^\\..*",
+  // Hidden files (e.g., .git, .DS_Store)
+  "\\.(jpg|jpeg|png|gif|bmp|svg|webp|ico)$",
+  // Image files
+  "\\.(mp3|wav|ogg|aac|flac)$",
+  // Audio files
+  "\\.(mp4|mov|avi|mkv|webm)$",
+  // Video files
+  "\\.(pdf|doc|docx|xls|xlsx|ppt|pptx)$",
+  // Document files
+  "\\.(zip|tar|gz|rar|7z)$"
+  // Compressed files
+];
+const DEFAULT_SECTION_SEPARATOR = "tag";
+const DEFAULT_SECTION_INDENTATION = true;
+const DEFAULT_SECTION_TITLE_PROPERTY = "title";
+const DEFAULT_FORMAT_OPTIONS = {
+  sectionSeparator: DEFAULT_SECTION_SEPARATOR,
+  sectionIndentation: DEFAULT_SECTION_INDENTATION,
+  sectionTitleProperty: DEFAULT_SECTION_TITLE_PROPERTY,
+  sectionDepth: 0
+};
+const DEFAULT_LOGGER = {
+  name: "default",
+  debug: (message, ...args) => console.debug(message, ...args),
+  info: (message, ...args) => console.info(message, ...args),
+  warn: (message, ...args) => console.warn(message, ...args),
+  error: (message, ...args) => console.error(message, ...args),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  verbose: (message, ...args) => {
+  },
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  silly: (message, ...args) => {
+  }
+};
+const wrapLogger = (toWrap, name) => {
+  const requiredMethods = ["debug", "info", "warn", "error", "verbose", "silly"];
+  const missingMethods = requiredMethods.filter((method) => typeof toWrap[method] !== "function");
+  if (missingMethods.length > 0) {
+    throw new Error(`Logger is missing required methods: ${missingMethods.join(", ")}`);
+  }
+  const log = (level, message, ...args) => {
+    message = `[${LIBRARY_NAME}] ${name ? `[${name}]` : ""}: ${message}`;
+    if (level === "debug") toWrap.debug(message, ...args);
+    else if (level === "info") toWrap.info(message, ...args);
+    else if (level === "warn") toWrap.warn(message, ...args);
+    else if (level === "error") toWrap.error(message, ...args);
+    else if (level === "verbose") toWrap.verbose(message, ...args);
+    else if (level === "silly") toWrap.silly(message, ...args);
+  };
+  return {
+    name: "wrapped",
+    debug: (message, ...args) => log("debug", message, ...args),
+    info: (message, ...args) => log("info", message, ...args),
+    warn: (message, ...args) => log("warn", message, ...args),
+    error: (message, ...args) => log("error", message, ...args),
+    verbose: (message, ...args) => log("verbose", message, ...args),
+    silly: (message, ...args) => log("silly", message, ...args)
+  };
+};
+class ModelRegistry {
+  configs;
+  cache;
+  logger;
+  constructor(logger) {
+    this.configs = [];
+    this.cache = /* @__PURE__ */ new Map();
+    this.logger = wrapLogger(logger || DEFAULT_LOGGER, "ModelRegistry");
+    this.registerDefaults();
+  }
+  /**
+   * Register default model configurations
+   */
+  registerDefaults() {
+    this.register({
+      pattern: /.*/,
+      // Matches anything
+      personaRole: "system",
+      encoding: "gpt-4o",
+      supportsToolCalls: true,
+      family: "unknown",
+      description: "Default fallback configuration"
+    });
+    this.register({
+      pattern: /^claude/i,
+      personaRole: "system",
+      encoding: "cl100k_base",
+      supportsToolCalls: true,
+      family: "claude",
+      description: "Claude family models"
+    });
+    this.register({
+      pattern: /^o\d+/i,
+      // Matches o1, o2, o3, o4, etc.
+      personaRole: "developer",
+      encoding: "gpt-4o",
+      supportsToolCalls: true,
+      family: "o-series",
+      description: "O-series reasoning models"
+    });
+    this.register({
+      pattern: /^gpt-4/i,
+      personaRole: "system",
+      encoding: "gpt-4o",
+      supportsToolCalls: true,
+      family: "gpt-4",
+      description: "GPT-4 family models"
+    });
+    this.logger.debug("Registered default model configurations");
+  }
+  /**
+   * Register a model configuration
+   * Configs are checked in registration order (first match wins)
+   * New configs are added to the beginning of the list (high priority)
+   */
+  register(config) {
+    if (!config.pattern && !config.exactMatch) {
+      throw new Error("Model config must have either pattern or exactMatch");
+    }
+    this.configs.unshift(config);
+    this.cache.clear();
+    this.logger.debug("Registered model config", {
+      family: config.family,
+      pattern: config.pattern?.source,
+      exactMatch: config.exactMatch
+    });
+  }
+  /**
+   * Get configuration for a model
+   */
+  getConfig(model) {
+    if (this.cache.has(model)) {
+      return this.cache.get(model);
+    }
+    for (const config of this.configs) {
+      if (config.exactMatch && config.exactMatch === model) {
+        this.cache.set(model, config);
+        return config;
+      }
+      if (config.pattern && config.pattern.test(model)) {
+        this.cache.set(model, config);
+        return config;
+      }
+    }
+    throw new Error(`No configuration found for model: ${model}`);
+  }
+  /**
+   * Get persona role for a model
+   */
+  getPersonaRole(model) {
+    return this.getConfig(model).personaRole;
+  }
+  /**
+   * Get tokenizer encoding for a model
+   */
+  getEncoding(model) {
+    return this.getConfig(model).encoding;
+  }
+  /**
+   * Check if model supports tool calls
+   */
+  supportsToolCalls(model) {
+    return this.getConfig(model).supportsToolCalls ?? true;
+  }
+  /**
+   * Get model family
+   */
+  getFamily(model) {
+    return this.getConfig(model).family;
+  }
+  /**
+   * Clear all registered configs and reset to defaults
+   */
+  reset() {
+    this.configs = [];
+    this.cache.clear();
+    this.registerDefaults();
+    this.logger.debug("Reset model configurations to defaults");
+  }
+  /**
+   * Clear cache (useful if configs are modified)
+   */
+  clearCache() {
+    this.cache.clear();
+    this.logger.debug("Cleared model configuration cache");
+  }
+  /**
+   * Get all registered configurations
+   */
+  getAllConfigs() {
+    return [...this.configs];
+  }
+}
+let globalRegistry = null;
+function getModelRegistry(logger) {
+  if (!globalRegistry) {
+    globalRegistry = new ModelRegistry(logger);
+  }
+  return globalRegistry;
+}
+function getPersonaRole$1(model) {
+  return getModelRegistry().getPersonaRole(model);
+}
+const getPersonaRole = (model) => {
+  return getPersonaRole$1(model);
+};
+const createRequest = (model) => {
+  const messages = [];
+  return {
+    model,
+    messages,
+    addMessage: (message) => {
+      messages.push(message);
+    }
+  };
+};
+const clean = (obj) => {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([_, v]) => v !== void 0)
+  );
+};
+const stringifyJSON = function(obj, visited = /* @__PURE__ */ new Set()) {
+  const arrOfKeyVals = [];
+  const arrVals = [];
+  let objKeys = [];
+  if (typeof obj === "number" || typeof obj === "boolean" || obj === null)
+    return "" + obj;
+  else if (typeof obj === "string")
+    return '"' + obj + '"';
+  if (obj instanceof Object && visited.has(obj)) {
+    return '"(circular)"';
+  } else if (Array.isArray(obj)) {
+    if (obj.length === 0)
+      return "[]";
+    else {
+      visited.add(obj);
+      obj.forEach(function(el) {
+        arrVals.push(stringifyJSON(el, visited));
+      });
+      return "[" + arrVals + "]";
+    }
+  } else if (obj instanceof Object) {
+    visited.add(obj);
+    objKeys = Object.keys(obj);
+    objKeys.forEach(function(key) {
+      const keyOut = '"' + key + '":';
+      const keyValOut = obj[key];
+      if (keyValOut instanceof Function || keyValOut === void 0)
+        return;
+      else if (typeof keyValOut === "string")
+        arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+      else if (typeof keyValOut === "boolean" || typeof keyValOut === "number" || keyValOut === null)
+        arrOfKeyVals.push(keyOut + keyValOut);
+      else if (keyValOut instanceof Object) {
+        arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
+      }
+    });
+    return "{" + arrOfKeyVals + "}";
+  }
+  return "";
+};
+const SectionSeparatorSchema = zod.z.enum(["tag", "markdown"]);
+const SectionTitlePropertySchema = zod.z.enum(["title", "name"]);
+const FormatOptionsSchema = zod.z.object({
+  sectionSeparator: SectionSeparatorSchema,
+  sectionIndentation: zod.z.boolean(),
+  sectionTitleProperty: SectionTitlePropertySchema,
+  sectionTitlePrefix: zod.z.string().optional(),
+  sectionTitleSeparator: zod.z.string().optional(),
+  sectionDepth: zod.z.number().default(0)
+});
+const OptionSchema = zod.z.object({
+  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+  formatOptions: FormatOptionsSchema.partial().optional().default(DEFAULT_FORMAT_OPTIONS)
+});
+function isSection(obj) {
+  return obj && typeof obj === "object" && "items" in obj && Array.isArray(obj.items);
+}
+function isWeighted(obj) {
+  return obj && typeof obj === "object" && "text" in obj;
+}
+const create$2 = (formatterOptions) => {
+  const options = OptionSchema.parse({});
+  const logger = wrapLogger(options.logger, "Formatter");
+  let formatOptions = DEFAULT_FORMAT_OPTIONS;
+  if (options?.formatOptions) {
+    formatOptions = {
+      ...formatOptions,
+      ...clean(options.formatOptions)
+    };
+  }
+  const formatPersona = (model, persona) => {
+    logger.silly(`Formatting persona`);
+    if (persona) {
+      const formattedPersona = formatSection(persona);
+      return {
+        role: getPersonaRole(model),
+        content: `${formattedPersona}`
+      };
+    } else {
+      throw new Error("Persona is required");
+    }
+  };
+  const format = (item, sectionDepth) => {
+    logger.silly(`Formatting ${isSection(item) ? "section" : "item"} Item: %s`, stringifyJSON(item));
+    const currentSectionDepth = sectionDepth ?? formatOptions.sectionDepth;
+    logger.silly(`		Current section depth: ${currentSectionDepth}`);
+    let result = "";
+    if (isSection(item)) {
+      result = formatSection(item, currentSectionDepth + 1);
+    } else if (isWeighted(item)) {
+      result = item.text;
+    } else {
+      result = "";
+    }
+    return result;
+  };
+  const formatSection = (section, sectionDepth) => {
+    logger.silly(`Formatting section`);
+    const currentSectionDepth = sectionDepth ?? formatOptions.sectionDepth;
+    logger.silly(`		Current section depth: ${currentSectionDepth}`);
+    if (section) {
+      const formattedItems = section.items.map((item) => format(item, currentSectionDepth)).join("\n\n");
+      if (formatOptions.sectionSeparator === "tag") {
+        return `<${section.title ?? "section"}>
+${formattedItems}
+</${section.title ?? "section"}>`;
+      } else {
+        const headingLevel = currentSectionDepth;
+        const hashes = "#".repeat(headingLevel);
+        logger.silly(`		Heading level: ${headingLevel}`);
+        logger.silly(`		Section title: ${section.title}`);
+        return `${hashes} ${formatOptions.sectionTitlePrefix ? `${formatOptions.sectionTitlePrefix} ${formatOptions.sectionTitleSeparator} ` : ""}${section.title}
+
+${formattedItems}`;
+      }
+    } else {
+      return "";
+    }
+  };
+  const formatArray = (items, sectionDepth) => {
+    logger.silly(`Formatting array`);
+    const currentSectionDepth = sectionDepth ?? formatOptions.sectionDepth;
+    return items.map((item) => format(item, currentSectionDepth)).join("\n\n");
+  };
+  const formatPrompt = (model, prompt) => {
+    logger.silly("Formatting prompt");
+    const chatRequest = createRequest(model);
+    if (prompt.persona) {
+      [prompt.persona].forEach((persona) => {
+        chatRequest.addMessage(formatPersona(model, persona));
+      });
+    }
+    let formattedAreas = formatSection(prompt.instructions) + "\n\n";
+    if (prompt.contents) {
+      formattedAreas += formatSection(prompt.contents) + "\n\n";
+    }
+    if (prompt.contexts) {
+      formattedAreas += formatSection(prompt.contexts) + "\n\n";
+    }
+    chatRequest.addMessage({
+      role: "user",
+      content: formattedAreas
+    });
+    return chatRequest;
+  };
+  return {
+    formatPersona,
+    format,
+    formatPrompt,
+    formatArray
+  };
+};
+zod.z.object({
+  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+  parameters: ParametersSchema.optional().default({})
+});
+const create$1 = (params) => {
+  const log = params.log || console.log;
+  const exists = async (path2) => {
+    try {
+      await fs__namespace.promises.stat(path2);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  };
+  const isDirectory2 = async (path2) => {
+    const stats = await fs__namespace.promises.stat(path2);
+    if (!stats.isDirectory()) {
+      log(`${path2} is not a directory`);
+      return false;
+    }
+    return true;
+  };
+  const isFile = async (path2) => {
+    const stats = await fs__namespace.promises.stat(path2);
+    if (!stats.isFile()) {
+      log(`${path2} is not a file`);
+      return false;
+    }
+    return true;
+  };
+  const isReadable = async (path2) => {
+    try {
+      await fs__namespace.promises.access(path2, fs__namespace.constants.R_OK);
+    } catch (error) {
+      log(`${path2} is not readable: %s %s`, error.message, error.stack);
+      return false;
+    }
+    return true;
+  };
+  const isWritable = async (path2) => {
+    try {
+      await fs__namespace.promises.access(path2, fs__namespace.constants.W_OK);
+    } catch (error) {
+      log(`${path2} is not writable: %s %s`, error.message, error.stack);
+      return false;
+    }
+    return true;
+  };
+  const isFileReadable = async (path2) => {
+    return await exists(path2) && await isFile(path2) && await isReadable(path2);
+  };
+  const isDirectoryWritable = async (path2) => {
+    return await exists(path2) && await isDirectory2(path2) && await isWritable(path2);
+  };
+  const isDirectoryReadable = async (path2) => {
+    return await exists(path2) && await isDirectory2(path2) && await isReadable(path2);
+  };
+  const createDirectory = async (path2) => {
+    try {
+      await fs__namespace.promises.mkdir(path2, { recursive: true });
+    } catch (mkdirError) {
+      throw new Error(`Failed to create output directory ${path2}: ${mkdirError.message} ${mkdirError.stack}`);
+    }
+  };
+  const readFile = async (path2, encoding) => {
+    return await fs__namespace.promises.readFile(path2, { encoding });
+  };
+  const writeFile = async (path2, data, encoding) => {
+    await fs__namespace.promises.writeFile(path2, data, { encoding });
+  };
+  const forEachFileIn = async (directory, callback, options = { pattern: "*.*" }) => {
+    try {
+      let filesProcessed = 0;
+      const files = await glob.glob(options.pattern, { cwd: directory, nodir: true });
+      for (const file of files) {
+        await callback(path.join(directory, file));
+        filesProcessed++;
+        if (options.limit && filesProcessed >= options.limit) {
+          log(`Reached limit of ${options.limit} files, stopping`);
+          break;
+        }
+      }
+    } catch (err) {
+      throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+    }
+  };
+  const readStream = async (path2) => {
+    return fs__namespace.createReadStream(path2);
+  };
+  const hashFile = async (path2, length) => {
+    const file = await readFile(path2, "utf8");
+    return crypto.createHash("sha256").update(file).digest("hex").slice(0, length);
+  };
+  const listFiles = async (directory) => {
+    return await fs__namespace.promises.readdir(directory);
+  };
+  return {
+    exists,
+    isDirectory: isDirectory2,
+    isFile,
+    isReadable,
+    isWritable,
+    isFileReadable,
+    isDirectoryWritable,
+    isDirectoryReadable,
+    createDirectory,
+    readFile,
+    readStream,
+    writeFile,
+    forEachFileIn,
+    hashFile,
+    listFiles
+  };
+};
+const OptionsSchema = zod.z.object({
+  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+  ignorePatterns: zod.z.array(zod.z.string()).optional().default(DEFAULT_IGNORE_PATTERNS),
+  parameters: ParametersSchema.optional().default({})
+});
+function extractFirstHeader(markdownText) {
+  const headerRegex = /^(#{1,6})\s+(.+?)(?:\n|$)/m;
+  const match = markdownText.match(headerRegex);
+  if (match && match[2]) {
+    return match[2].trim();
+  }
+  return null;
+}
+function removeFirstHeader(markdownText) {
+  const headerRegex = /^(#{1,6})\s+(.+?)(?:\n|$)/m;
+  const match = markdownText.match(headerRegex);
+  if (match) {
+    return markdownText.replace(headerRegex, "").trim();
+  }
+  return markdownText;
+}
+const create = (loaderOptions) => {
+  const options = OptionsSchema.parse({});
+  const parameters = options.parameters;
+  const logger = wrapLogger(options.logger, "Loader");
+  const ignorePatterns = options.ignorePatterns;
+  const loadOptions = (sectionOptions = {}) => {
+    const currentOptions = SectionOptionsSchema.parse(sectionOptions);
+    return {
+      ...currentOptions,
+      parameters: {
+        ...parameters,
+        ...currentOptions.parameters
+      }
+    };
+  };
+  const load = async (contextDirectories = [], options2 = {}) => {
+    const sectionOptions = loadOptions(options2);
+    logger.debug(`Loading context from ${contextDirectories}`);
+    const contextSections = [];
+    if (!contextDirectories || contextDirectories.length === 0) {
+      logger.debug(`No context directories provided, returning empty context`);
+      return contextSections;
+    }
+    const storage = create$1({ log: logger.debug });
+    for (const contextDir of contextDirectories) {
+      try {
+        const dirName = path.basename(contextDir);
+        logger.debug(`Processing context directory ${dirName}`);
+        let mainContextSection;
+        const contextFile = path.join(contextDir, "context.md");
+        if (await storage.exists(contextFile)) {
+          logger.debug(`Found context.md file in ${contextDir}`);
+          const mainContextContent = await storage.readFile(contextFile, "utf8");
+          const firstHeader = extractFirstHeader(mainContextContent);
+          const sectionTitle = firstHeader || dirName;
+          mainContextSection = create$4({ ...sectionOptions, title: sectionTitle });
+          if (firstHeader) {
+            mainContextSection.add(removeFirstHeader(mainContextContent), { ...sectionOptions });
+          } else {
+            mainContextSection.add(mainContextContent, { ...sectionOptions });
+          }
+        } else {
+          mainContextSection = create$4({ ...sectionOptions, title: dirName });
+        }
+        const files = await storage.listFiles(contextDir);
+        const ignorePatternsRegex = ignorePatterns.map((pattern) => {
+          try {
+            return new RegExp(pattern, "i");
+          } catch (error) {
+            logger.error(`Invalid ignore pattern: ${pattern}`, { error });
+            return /(?!)/;
+          }
+        });
+        const filteredFiles = files.filter((file) => {
+          const fullPath = path.join(contextDir, file);
+          return !ignorePatternsRegex.some((regex) => regex.test(file) || regex.test(fullPath));
+        });
+        for (const file of filteredFiles) {
+          if (file === "context.md") continue;
+          logger.debug(`Processing file ${file} in ${contextDir}`);
+          const filePath = path.join(contextDir, file);
+          if (await storage.isFile(filePath)) {
+            const fileContent = await storage.readFile(filePath, "utf8");
+            let sectionName = file;
+            let contentToAdd = fileContent;
+            if (file.endsWith(".md")) {
+              const fileHeader = extractFirstHeader(fileContent);
+              if (fileHeader) {
+                sectionName = fileHeader;
+                contentToAdd = removeFirstHeader(fileContent);
+              }
+            }
+            const fileSection = create$4({ ...sectionOptions, title: sectionName });
+            fileSection.add(contentToAdd, { ...sectionOptions });
+            mainContextSection.add(fileSection, { ...sectionOptions });
+          }
+        }
+        contextSections.push(mainContextSection);
+      } catch (error) {
+        logger.error(`Error processing context directory ${contextDir}: ${error}`);
+      }
+    }
+    return contextSections;
+  };
+  return {
+    load
+  };
+};
+zod.z.object({
+  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+  configDirs: zod.z.array(zod.z.string()).default(["./overrides"]),
+  overrides: zod.z.boolean().default(false),
+  parameters: ParametersSchema.optional().default({})
+});
+zod.z.object({
+  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+  basePath: zod.z.string(),
+  overridePaths: zod.z.array(zod.z.string()).optional().default(["./"]),
+  overrides: zod.z.boolean().optional().default(false),
+  parameters: ParametersSchema.optional().default({})
+});
+zod.z.object({
+  model: zod.z.string(),
+  formatter: zod.z.any().optional(),
+  trackContext: zod.z.boolean().optional().default(true),
+  deduplicateContext: zod.z.boolean().optional().default(true)
+});
+zod.z.object({
+  name: zod.z.string().min(1),
+  description: zod.z.string().min(1),
+  parameters: zod.z.object({
+    type: zod.z.literal("object"),
+    properties: zod.z.record(zod.z.string(), zod.z.any()).default({}),
+    // Allow any parameter structure
+    required: zod.z.array(zod.z.string()).optional()
+  }).passthrough(),
+  // Allow additional fields
+  execute: zod.z.custom(
+    (val) => typeof val === "function",
+    { message: "execute must be a function" }
+  ),
+  category: zod.z.string().optional(),
+  cost: zod.z.enum(["cheap", "moderate", "expensive"]).optional(),
+  examples: zod.z.array(zod.z.object({
+    scenario: zod.z.string(),
+    params: zod.z.any(),
+    expectedResult: zod.z.string()
+  })).optional()
+}).passthrough();
+const ContentItemSchema = zod.z.union([
+  zod.z.string(),
+  // Simple string content
+  zod.z.object({
+    content: zod.z.string(),
+    title: zod.z.string().optional(),
+    weight: zod.z.number().optional()
+  }),
+  zod.z.object({
+    path: zod.z.string(),
+    title: zod.z.string().optional(),
+    weight: zod.z.number().optional()
+  }),
+  zod.z.object({
+    directories: zod.z.array(zod.z.string()),
+    title: zod.z.string().optional(),
+    weight: zod.z.number().optional()
+  })
+]);
+zod.z.object({
+  // Core settings
+  basePath: zod.z.string(),
+  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+  overridePaths: zod.z.array(zod.z.string()).optional().default(["./"]),
+  overrides: zod.z.boolean().optional().default(false),
+  parameters: ParametersSchema.optional().default({}),
+  // Content sections
+  persona: ContentItemSchema.optional(),
+  instructions: zod.z.array(ContentItemSchema).optional().default([]),
+  content: zod.z.array(ContentItemSchema).optional().default([]),
+  context: zod.z.array(ContentItemSchema).optional().default([]),
+  // Templates and inheritance
+  extends: zod.z.string().optional(),
+  // Extend another recipe
+  template: zod.z.string().optional(),
+  // Generic template name
+  // Tool integration
+  tools: zod.z.any().optional(),
+  // Tool[] | ToolRegistry
+  toolGuidance: zod.z.union([
+    zod.z.enum(["auto", "minimal", "detailed"]),
+    zod.z.object({
+      strategy: zod.z.enum(["adaptive", "prescriptive", "minimal"]),
+      includeExamples: zod.z.boolean().optional(),
+      explainWhenToUse: zod.z.boolean().optional(),
+      includeCategories: zod.z.boolean().optional(),
+      customInstructions: zod.z.string().optional()
+    })
+  ]).optional(),
+  toolCategories: zod.z.array(zod.z.string()).optional()
+});
+const toJSON = (prompt) => {
+  return JSON.stringify(prompt, null, 2);
+};
+const escapeXML = (str) => {
+  return str.replace(/[<>&'"]/g, (c) => {
+    switch (c) {
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "&":
+        return "&amp;";
+      case "'":
+        return "&apos;";
+      case '"':
+        return "&quot;";
+      default:
+        return c;
+    }
+  });
+};
+const itemToXML = (item) => {
+  if (typeof item === "string") {
+    return `<item>${escapeXML(item)}</item>`;
+  }
+  if (item && typeof item === "object" && "items" in item) {
+    return sectionToXML(item);
+  }
+  if (item && typeof item === "object" && "text" in item) {
+    const weightAttr = item.weight !== void 0 && item.weight !== null ? ` weight="${item.weight}"` : "";
+    return `<item${weightAttr}>${escapeXML(item.text)}</item>`;
+  }
+  return "";
+};
+const sectionToXML = (section, tagName = "section") => {
+  const titleAttr = section.title ? ` title="${escapeXML(section.title)}"` : "";
+  const weightAttr = section.weight ? ` weight="${section.weight}"` : "";
+  let xml = `<${tagName}${titleAttr}${weightAttr}>`;
+  if (section.items && Array.isArray(section.items)) {
+    xml += section.items.map((item) => itemToXML(item)).join("");
+  }
+  xml += `</${tagName}>`;
+  return xml;
+};
+const toXML = (prompt) => {
+  let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<prompt>';
+  if (prompt.persona) {
+    xml += sectionToXML(prompt.persona, "persona");
+  }
+  if (prompt.instructions) {
+    xml += sectionToXML(prompt.instructions, "instructions");
+  }
+  if (prompt.contents) {
+    xml += sectionToXML(prompt.contents, "contents");
+  }
+  if (prompt.contexts) {
+    xml += sectionToXML(prompt.contexts, "contexts");
+  }
+  xml += "</prompt>";
+  return xml;
+};
+const parseSectionFromJSON = (jsonSection) => {
+  if (!jsonSection || !jsonSection.items) {
+    throw new Error("Invalid section structure");
+  }
+  const section = create$4({
+    title: jsonSection.title,
+    weight: jsonSection.weight
+  });
+  for (const item of jsonSection.items) {
+    if (typeof item === "object" && "items" in item) {
+      section.add(parseSectionFromJSON(item));
+    } else if (typeof item === "object" && "text" in item) {
+      section.add({
+        text: item.text,
+        weight: item.weight
+      });
+    } else if (typeof item === "string") {
+      section.add(item);
+    }
+  }
+  return section;
+};
+const fromJSON = (jsonString) => {
+  const json = JSON.parse(jsonString);
+  const persona = json.persona ? parseSectionFromJSON(json.persona) : void 0;
+  const instructions = json.instructions ? parseSectionFromJSON(json.instructions) : create$4({ title: "Instructions" });
+  const contents = json.contents ? parseSectionFromJSON(json.contents) : void 0;
+  const contexts = json.contexts ? parseSectionFromJSON(json.contexts) : void 0;
+  return create$3({
+    persona,
+    instructions,
+    contents,
+    contexts
+  });
+};
+const parseNodeToSection = (node) => {
+  const children = node.section || node.persona || node.instructions || node.contents || node.contexts || [];
+  let attributes = node[":@"] || {};
+  if (!node[":@"] && Array.isArray(children)) {
+    for (const child of children) {
+      if (child[":@"]) {
+        attributes = child[":@"];
+        break;
+      }
+    }
+  }
+  const title = attributes["@_title"];
+  const weight = attributes["@_weight"] ? Number(attributes["@_weight"]) : void 0;
+  const section = create$4({ title, weight });
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      const key = Object.keys(child)[0];
+      if (key === ":@") continue;
+      if (key === "item") {
+        const itemContent = child.item;
+        let text = "";
+        let itemWeight = void 0;
+        for (const part of itemContent) {
+          const keys = Object.keys(part);
+          if (keys.includes("#text")) {
+            text = part["#text"];
+          } else if (keys.includes(":@")) {
+            const attrs = part[":@"];
+            const w = attrs["@_weight"] || attrs["weight"];
+            if (w !== void 0) itemWeight = Number(w);
+          } else {
+            const w = part["@_weight"] || part["weight"];
+            if (w !== void 0) itemWeight = Number(w);
+          }
+        }
+        section.add({ text, weight: itemWeight });
+      } else if (key === "section") {
+        section.add(parseNodeToSection(child));
+      }
+    }
+  }
+  return section;
+};
+const fromXML = (xmlString) => {
+  const parser = new fastXmlParser.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    preserveOrder: true,
+    trimValues: true
+  });
+  const parsed = parser.parse(xmlString);
+  let promptNode = null;
+  for (const node of parsed) {
+    if (node.prompt) {
+      promptNode = node.prompt;
+      break;
+    }
+  }
+  if (!promptNode) throw new Error("Invalid XML: missing <prompt> root");
+  let persona;
+  let instructions = create$4({ title: "Instructions" });
+  let contents;
+  let contexts;
+  for (const child of promptNode) {
+    if (child.persona) {
+      persona = parseNodeToSection(child);
+      persona.title = "Persona";
+    } else if (child.instructions) {
+      instructions = parseNodeToSection(child);
+      instructions.title = "Instructions";
+    } else if (child.contents) {
+      contents = parseNodeToSection(child);
+      contents.title = "Contents";
+    } else if (child.contexts) {
+      contexts = parseNodeToSection(child);
+      contexts.title = "Contexts";
+    }
+  }
+  return create$3({
+    persona,
+    instructions,
+    contents,
+    contexts
+  });
+};
+const saveToDirectory = async (prompt, basePath) => {
+  await fs__namespace$1.mkdir(basePath, { recursive: true });
+  if (prompt.persona) {
+    await saveSection(prompt.persona, path__namespace.join(basePath, "persona"));
+  }
+  if (prompt.instructions) {
+    await saveSection(prompt.instructions, path__namespace.join(basePath, "instructions"));
+  }
+  if (prompt.contexts) {
+    await saveSection(prompt.contexts, path__namespace.join(basePath, "context"));
+  }
+  if (prompt.contents) {
+    await saveSection(prompt.contents, path__namespace.join(basePath, "content"));
+  }
+};
+const saveSection = async (section, targetPath) => {
+  const hasSubsections = section.items.some(
+    (item) => typeof item === "object" && "items" in item
+  );
+  if (!hasSubsections) {
+    const content = section.items.map((item) => {
+      if (typeof item === "string") return item;
+      return item.text;
+    }).join("\n\n");
+    await fs__namespace$1.writeFile(`${targetPath}.md`, content);
+    return;
+  }
+  await fs__namespace$1.mkdir(targetPath, { recursive: true });
+  for (let i = 0; i < section.items.length; i++) {
+    const item = section.items[i];
+    if (typeof item === "object" && "items" in item) {
+      const subTitle = item.title || `part-${i + 1}`;
+      const subPath = path__namespace.join(targetPath, subTitle);
+      await saveSection(item, subPath);
+    } else {
+      const fileName = `item-${i + 1}.md`;
+      const content = typeof item === "string" ? item : item.text;
+      await fs__namespace$1.writeFile(path__namespace.join(targetPath, fileName), content);
+    }
+  }
+};
+class OpenAIProvider {
+  async execute(request, options = {}) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) throw new Error("OpenAI API key is required");
+    const client = new OpenAI({ apiKey });
+    const model = options.model || request.model || "gpt-4";
+    const messages = request.messages.map((msg) => {
+      const role = msg.role === "developer" ? "system" : msg.role;
+      return {
+        role,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        name: msg.name
+      };
+    });
+    const response = await client.chat.completions.create({
+      model,
+      messages,
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    const choice = response.choices[0];
+    return {
+      content: choice.message.content || "",
+      model: response.model,
+      usage: response.usage ? {
+        inputTokens: response.usage.prompt_tokens,
+        outputTokens: response.usage.completion_tokens
+      } : void 0
+    };
+  }
+}
+class AnthropicProvider {
+  async execute(request, options = {}) {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) throw new Error("Anthropic API key is required");
+    const client = new Anthropic({ apiKey });
+    const model = options.model || request.model || "claude-3-opus-20240229";
+    let systemPrompt = "";
+    const messages = [];
+    for (const msg of request.messages) {
+      if (msg.role === "system" || msg.role === "developer") {
+        systemPrompt += (typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)) + "\n\n";
+      } else {
+        messages.push({
+          role: msg.role,
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        });
+      }
+    }
+    const response = await client.messages.create({
+      model,
+      system: systemPrompt.trim() || void 0,
+      messages,
+      max_tokens: options.maxTokens || 4096,
+      // Anthropic requires max_tokens
+      temperature: options.temperature
+    });
+    const contentBlock = response.content[0];
+    const text = contentBlock.type === "text" ? contentBlock.text : "";
+    return {
+      content: text,
+      model: response.model,
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens
+      }
+    };
+  }
+}
+class GeminiProvider {
+  async execute(request, options = {}) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY;
+    if (!apiKey) throw new Error("Gemini API key is required");
+    const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
+    const modelName = options.model || request.model || "gemini-1.5-pro";
+    let systemInstruction = "";
+    for (const msg of request.messages) {
+      if (msg.role === "system" || msg.role === "developer") {
+        systemInstruction += (typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)) + "\n\n";
+      }
+    }
+    const configuredModel = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemInstruction ? systemInstruction.trim() : void 0
+    });
+    const chatHistory = [];
+    let lastUserMessage = "";
+    for (const msg of request.messages) {
+      if (msg.role === "system" || msg.role === "developer") continue;
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      if (msg.role === "user") {
+        lastUserMessage = content;
+      }
+      chatHistory.push({
+        role: msg.role === "assistant" ? "model" : "user",
+        parts: [{ text: content }]
+      });
+    }
+    let result;
+    if (chatHistory.length > 1) {
+      const lastMsg = chatHistory.pop();
+      const chat = configuredModel.startChat({
+        history: chatHistory
+      });
+      result = await chat.sendMessage(lastMsg?.parts[0].text || "");
+    } else {
+      result = await configuredModel.generateContent(lastUserMessage || " ");
+    }
+    const response = await result.response;
+    const text = response.text();
+    return {
+      content: text,
+      model: modelName,
+      // Gemini usage metadata usageMetadata
+      usage: response.usageMetadata ? {
+        inputTokens: response.usageMetadata.promptTokenCount,
+        outputTokens: response.usageMetadata.candidatesTokenCount
+      } : void 0
+    };
+  }
+}
+class ExecutionManager {
+  providers;
+  constructor() {
+    this.providers = /* @__PURE__ */ new Map();
+    this.providers.set("openai", new OpenAIProvider());
+    this.providers.set("anthropic", new AnthropicProvider());
+    this.providers.set("gemini", new GeminiProvider());
+  }
+  getProvider(model) {
+    if (!model) {
+      return this.providers.get("openai");
+    }
+    if (model.startsWith("gpt") || model.startsWith("o1")) {
+      return this.providers.get("openai");
+    } else if (model.startsWith("claude")) {
+      return this.providers.get("anthropic");
+    } else if (model.startsWith("gemini")) {
+      return this.providers.get("gemini");
+    }
+    return this.providers.get("openai");
+  }
+  async execute(request, options = {}) {
+    const model = options.model || request.model;
+    const provider = this.getProvider(model);
+    return provider.execute(request, options);
+  }
+}
+const execute = async (request, options = {}) => {
+  const manager = new ExecutionManager();
+  return manager.execute(request, options);
+};
+const program = new commander.Command();
+const configManager = cardigantime.create({
+  configShape: ConfigSchema.shape,
+  defaults: {
+    configDirectory: process.cwd(),
+    configFile: "riotprompt.yaml"
+  }
+});
+program.name("riotprompt").description("CLI tool for analyzing and processing prompts").version("0.0.1");
+async function isDirectory(path2) {
+  try {
+    const stat = await fs__namespace$1.stat(path2);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists(path2) {
+  try {
+    await fs__namespace$1.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadPromptFromDirectory(absolutePromptPath) {
+  let personaSection;
+  let instructionsSection;
+  let contextSection;
+  const loader = create();
+  const personaDir = path__namespace.join(absolutePromptPath, "persona");
+  const personaFile = path__namespace.join(absolutePromptPath, "persona.md");
+  if (await isDirectory(personaDir)) {
+    console.log("Loading persona from directory...");
+    const personaSections = await loader.load([personaDir]);
+    if (personaSections.length > 0) {
+      personaSection = create$4({ title: "Persona" });
+      personaSections.forEach((section) => {
+        personaSection.add(section);
+      });
+    }
+  } else if (await fileExists(personaFile)) {
+    console.log("Loading persona from file...");
+    const personaContent = await fs__namespace$1.readFile(personaFile, "utf-8");
+    personaSection = create$4({ title: "Persona" });
+    personaSection.add(create$5(personaContent));
+  } else {
+    console.log("No persona found, skipping.");
+  }
+  const instructionsDir = path__namespace.join(absolutePromptPath, "instructions");
+  const instructionsFile = path__namespace.join(absolutePromptPath, "instructions.md");
+  if (await isDirectory(instructionsDir)) {
+    console.log("Loading instructions from directory...");
+    const instructionSections = await loader.load([instructionsDir]);
+    if (instructionSections.length > 0) {
+      instructionsSection = create$4({ title: "Instructions" });
+      instructionSections.forEach((section) => {
+        instructionsSection.add(section);
+      });
+    }
+  } else if (await fileExists(instructionsFile)) {
+    console.log("Loading instructions from file...");
+    const instructionsContent = await fs__namespace$1.readFile(instructionsFile, "utf-8");
+    instructionsSection = create$4({ title: "Instructions" });
+    instructionsSection.add(create$5(instructionsContent));
+  }
+  if (!instructionsSection) {
+    throw new Error("instructions (directory or .md file) is required.");
+  }
+  const contextDir = path__namespace.join(absolutePromptPath, "context");
+  if (await isDirectory(contextDir)) {
+    console.log("Loading context from directory...");
+    const contextSections = await loader.load([contextDir]);
+    if (contextSections.length > 0) {
+      contextSection = create$4({ title: "Context" });
+      contextSections.forEach((section) => {
+        contextSection.add(section);
+      });
+    }
+  } else {
+    console.log("No context directory found, skipping context.");
+  }
+  return create$3({
+    persona: personaSection,
+    instructions: instructionsSection,
+    contexts: contextSection
+  });
+}
+async function createAction(promptName, options) {
+  try {
+    const basePath = path__namespace.resolve(options.path, promptName);
+    if (await fileExists(basePath)) {
+      console.error(`Error: Directory ${basePath} already exists.`);
+      process.exit(1);
+    }
+    if (options.import) {
+      console.log(`Importing prompt from ${options.import} to ${basePath}...`);
+      const content = await fs__namespace$1.readFile(options.import, "utf-8");
+      let prompt;
+      if (options.import.endsWith(".json")) {
+        prompt = fromJSON(content);
+      } else if (options.import.endsWith(".xml")) {
+        prompt = fromXML(content);
+      } else {
+        throw new Error("Unsupported file extension. Use .json or .xml");
+      }
+      await saveToDirectory(prompt, basePath);
+      console.log(`Successfully imported to ${basePath}`);
+    } else {
+      console.log(`Creating prompt structure at ${basePath}...`);
+      await fs__namespace$1.mkdir(basePath, { recursive: true });
+      const personaText = options.persona || "You are a helpful AI assistant.";
+      await fs__namespace$1.writeFile(path__namespace.join(basePath, "persona.md"), personaText);
+      console.log("Created persona.md");
+      const instructionsText = options.instructions || "Please analyze the following request.";
+      await fs__namespace$1.writeFile(path__namespace.join(basePath, "instructions.md"), instructionsText);
+      console.log("Created instructions.md");
+      if (options.context) {
+        const contextDir = path__namespace.join(basePath, "context");
+        await fs__namespace$1.mkdir(contextDir);
+        await fs__namespace$1.writeFile(path__namespace.join(contextDir, "README.md"), "Place context files (json, md, txt) in this directory.");
+        console.log("Created context directory");
+      }
+      console.log(`
+Prompt '${promptName}' created successfully!`);
+    }
+    console.log(`Run 'riotprompt process ${path__namespace.join(options.path, promptName)}' to test it.`);
+  } catch (error) {
+    console.error("Error creating prompt:", error);
+    process.exit(1);
+  }
+}
+async function processAction(promptPath, options) {
+  try {
+    const config = await configManager.read(options);
+    const modelName = options.model || config.defaultModel;
+    console.log(`Processing prompt from: ${promptPath}`);
+    console.log(`Using model: ${modelName}`);
+    const absolutePromptPath = path__namespace.resolve(promptPath);
+    if (!await fileExists(absolutePromptPath)) {
+      console.error(`Error: Prompt path not found at ${absolutePromptPath}`);
+      process.exit(1);
+    }
+    let prompt;
+    if (await isDirectory(absolutePromptPath)) {
+      prompt = await loadPromptFromDirectory(absolutePromptPath);
+    } else {
+      const content = await fs__namespace$1.readFile(absolutePromptPath, "utf-8");
+      if (absolutePromptPath.endsWith(".json")) {
+        prompt = fromJSON(content);
+      } else if (absolutePromptPath.endsWith(".xml")) {
+        prompt = fromXML(content);
+      } else {
+        console.error("Error: Supported file formats are .json and .xml");
+        process.exit(1);
+      }
+    }
+    let output = "";
+    if (options.format === "json") {
+      output = toJSON(prompt);
+    } else if (options.format === "xml") {
+      output = toXML(prompt);
+    } else {
+      const model = modelName;
+      const formatter = create$2();
+      const chatRequest = formatter.formatPrompt(model, prompt);
+      if (chatRequest.messages) {
+        output = chatRequest.messages.map((m) => `--- ROLE: ${m.role} ---
+${m.content}`).join("\n\n");
+      } else {
+        output = JSON.stringify(chatRequest, null, 2);
+      }
+    }
+    if (options.output) {
+      await fs__namespace$1.writeFile(options.output, output);
+      console.log(`Output written to ${options.output}`);
+    } else {
+      console.log("\n--- Result ---\n");
+      console.log(output);
+    }
+  } catch (error) {
+    console.error("Error processing prompt:", error);
+    process.exit(1);
+  }
+}
+async function executeAction(promptPath, options) {
+  try {
+    const config = await configManager.read(options);
+    const modelName = options.model || config.defaultModel;
+    console.log(`Executing prompt from: ${promptPath}`);
+    console.log(`Using model: ${modelName}`);
+    const absolutePromptPath = path__namespace.resolve(promptPath);
+    if (!await fileExists(absolutePromptPath)) {
+      console.error(`Error: Prompt path not found at ${absolutePromptPath}`);
+      process.exit(1);
+    }
+    let prompt;
+    if (await isDirectory(absolutePromptPath)) {
+      prompt = await loadPromptFromDirectory(absolutePromptPath);
+    } else {
+      const content = await fs__namespace$1.readFile(absolutePromptPath, "utf-8");
+      if (absolutePromptPath.endsWith(".json")) {
+        prompt = fromJSON(content);
+      } else if (absolutePromptPath.endsWith(".xml")) {
+        prompt = fromXML(content);
+      } else {
+        console.error("Error: Supported file formats are .json and .xml");
+        process.exit(1);
+      }
+    }
+    const formatter = create$2();
+    const chatRequest = formatter.formatPrompt(modelName, prompt);
+    const executionOptions = {
+      apiKey: options.key,
+      model: modelName,
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    };
+    const result = await execute(chatRequest, executionOptions);
+    console.log("\n--- Response ---\n");
+    console.log(result.content);
+    if (result.usage) {
+      console.log("\n--- Usage ---");
+      console.log(`Input Tokens: ${result.usage.inputTokens}`);
+      console.log(`Output Tokens: ${result.usage.outputTokens}`);
+    }
+  } catch (error) {
+    console.error("Error executing prompt:", error.message || error);
+    process.exit(1);
+  }
+}
+async function main() {
+  await configManager.configure(program);
+  program.command("create <promptName>").description("Create a new prompt directory structure or import from file").option("-p, --path <path>", "Base path to create the prompt in", ".").option("--persona <text>", "Initial text for persona.md").option("--instructions <text>", "Initial text for instructions.md").option("--context", "Create context directory with placeholder", true).option("--no-context", "Do not create context directory").option("--import <file>", "Import prompt structure from a JSON or XML file").action(createAction);
+  program.command("process <promptPath>").description("Process a prompt (directory, JSON, or XML) and output the formatted prompt").option("-m, --model <model>", "Model to format for (e.g., gpt-4, claude)").option("-o, --output <file>", "Output file path").option("--format <format>", "Output format (text, json, xml)", "text").action(processAction);
+  program.command("execute <promptPath>").description("Execute a prompt using an LLM provider").option("-m, --model <model>", "Model to use (e.g., gpt-4, claude-3-opus, gemini-1.5-pro)").option("-k, --key <key>", "API Key (overrides env vars)").option("-t, --temperature <number>", "Temperature (0-1)", parseFloat).option("--max-tokens <number>", "Max tokens", parseInt).action(executeAction);
+  await program.parseAsync();
+}
+if (typeof require !== "undefined" && require.main === module) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+exports.createAction = createAction;
+exports.executeAction = executeAction;
+exports.fileExists = fileExists;
+exports.isDirectory = isDirectory;
+exports.loadPromptFromDirectory = loadPromptFromDirectory;
+exports.main = main;
+exports.processAction = processAction;