@riotprompt/riotprompt 0.0.1

package/dist/riotprompt.cjs

@@ -0,0 +1,1359 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const zod = require('zod');
+const fs = require('fs/promises');
+const path = require('path');
+const marked = require('marked');
+const fs$1 = require('fs');
+const glob = require('glob');
+const crypto = require('crypto');
+
+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 = /*#__PURE__*/_interopNamespaceDefault(fs);
+const path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+const fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$1);
+
+const parameters.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 create$9 = (parameters)=>{
+    return parameters;
+};
+const apply = (text, parameters)=>{
+    if (!parameters) {
+        return text;
+    }
+    // First, trim parameters keys to handle whitespace in placeholder names
+    const trimmedParams = {};
+    Object.keys(parameters).forEach((key)=>{
+        trimmedParams[key.trim()] = parameters[key];
+    });
+    // Process all placeholders, preserving ones that don't have matching parameters
+    return text.replace(/\{\{([^{}]+)\}\}/g, (match, p1)=>{
+        const paramKey = p1.trim();
+        const parameter = trimmedParams[paramKey];
+        if (parameter === undefined) {
+            // Preserve the original placeholder if parameter doesn't exist
+            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 weighted.WeightedOptionsSchema = zod.z.object({
+    weight: zod.z.number().optional(),
+    parameters: parameters.ParametersSchema.optional()
+});
+const create$8 = (text, options = {})=>{
+    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
+    const parameterizedText = apply(text, weightedOptions.parameters);
+    return {
+        text: parameterizedText,
+        weight: weightedOptions.weight
+    };
+};
+
+// Export create function
+const create$7 = (text, options = {})=>{
+    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
+    return create$8(text, weightedOptions);
+};
+
+const create$6 = (text, options = {})=>{
+    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
+    return create$8(text, weightedOptions);
+};
+
+const create$5 = (text, options = {})=>{
+    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
+    return create$8(text, weightedOptions);
+};
+
+const section.SectionOptionsSchema = zod.z.object({
+    title: zod.z.string().optional(),
+    weight: zod.z.number().optional(),
+    itemWeight: zod.z.number().optional(),
+    parameters: parameters.ParametersSchema.optional().default({})
+});
+const create$4 = (options = {})=>{
+    const items = [];
+    const sectionOptions = section.SectionOptionsSchema.parse(options);
+    const sectionItemOptions = weighted.WeightedOptionsSchema.parse({
+        ...sectionOptions,
+        weight: sectionOptions.itemWeight
+    });
+    const append = (item, options = {})=>{
+        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        itemOptions = {
+            ...sectionItemOptions,
+            ...itemOptions
+        };
+        if (Array.isArray(item)) {
+            item.forEach((item)=>{
+                append(item);
+            });
+        } else {
+            if (typeof item === 'string') {
+                items.push(create$8(item, itemOptions));
+            } else {
+                items.push(item);
+            }
+        }
+        return section$1;
+    };
+    const prepend = (item, options = {})=>{
+        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        itemOptions = {
+            ...sectionItemOptions,
+            ...itemOptions
+        };
+        if (Array.isArray(item)) {
+            item.forEach((item)=>{
+                prepend(item);
+            });
+        } else {
+            if (typeof item === 'string') {
+                items.unshift(create$8(item, itemOptions));
+            } else {
+                items.unshift(item);
+            }
+        }
+        return section$1;
+    };
+    const insert = (index, item, options = {})=>{
+        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        itemOptions = {
+            ...sectionItemOptions,
+            ...itemOptions
+        };
+        if (Array.isArray(item)) {
+            item.forEach((item)=>{
+                insert(index, item);
+            });
+        } else {
+            if (typeof item === 'string') {
+                items.splice(index, 0, create$8(item, itemOptions));
+            } else {
+                items.splice(index, 0, item);
+            }
+        }
+        return section$1;
+    };
+    const remove = (index)=>{
+        items.splice(index, 1);
+        return section$1;
+    };
+    const replace = (index, item, options = {})=>{
+        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        itemOptions = {
+            ...sectionItemOptions,
+            ...itemOptions
+        };
+        if (typeof item === 'string') {
+            items[index] = create$8(item, itemOptions);
+        } else {
+            items[index] = item;
+        }
+        return section$1;
+    };
+    const add = (item, options = {})=>{
+        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        itemOptions = {
+            ...sectionItemOptions,
+            ...itemOptions
+        };
+        return append(item, itemOptions);
+    };
+    const section$1 = {
+        title: sectionOptions.title,
+        items,
+        weight: sectionOptions.weight,
+        add,
+        append,
+        prepend,
+        insert,
+        remove,
+        replace
+    };
+    return section$1;
+};
+
+const create$3 = (text, options = {})=>{
+    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
+    return create$8(text, weightedOptions);
+};
+
+const create$2 = ({ persona, instructions, contents, contexts })=>{
+    return {
+        persona,
+        instructions,
+        contents,
+        contexts
+    };
+};
+
+const constants.DEFAULT_CHARACTER_ENCODING = "utf8";
+const constants.LIBRARY_NAME = "riotprompt";
+const DEFAULT_PERSONA_ROLE = "developer";
+const DEFAULT_IGNORE_PATTERNS = [
+    "^\\..*",
+    "\\.(jpg|jpeg|png|gif|bmp|svg|webp|ico)$",
+    "\\.(mp3|wav|ogg|aac|flac)$",
+    "\\.(mp4|mov|avi|mkv|webm)$",
+    "\\.(pdf|doc|docx|xls|xlsx|ppt|pptx)$",
+    "\\.(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 getPersonaRole = (model)=>{
+    if (model === "gpt-4o" || model === "gpt-4o-mini") {
+        return "system";
+    }
+    return DEFAULT_PERSONA_ROLE;
+};
+const createRequest = (model)=>{
+    const messages = [];
+    return {
+        model,
+        messages,
+        addMessage: (message)=>{
+            messages.push(message);
+        }
+    };
+};
+
+const chat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    createRequest,
+    getPersonaRole
+}, Symbol.toStringTag, { value: 'Module' }));
+
+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),
+    verbose: (message, ...args)=>console.log(message, ...args),
+    silly: (message, ...args)=>console.log(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 = `[${constants.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)
+    };
+};
+
+const clean = (obj)=>{
+    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
+};
+//Recursive implementation of jSON.stringify;
+const stringifyJSON = function(obj, visited = new Set()) {
+    const arrOfKeyVals = [];
+    const arrVals = [];
+    let objKeys = [];
+    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
+    else if (typeof obj === 'string') return '"' + obj + '"';
+    /*********DETECT CIRCULAR REFERENCES**********/ if (obj instanceof Object && visited.has(obj)) {
+        return '"(circular)"';
+    } else if (Array.isArray(obj)) {
+        //check for empty array
+        if (obj[0] === undefined) return '[]';
+        else {
+            // Add array to visited before processing its elements
+            visited.add(obj);
+            obj.forEach(function(el) {
+                arrVals.push(stringifyJSON(el, visited));
+            });
+            return '[' + arrVals + ']';
+        }
+    } else if (obj instanceof Object) {
+        // Add object to visited before processing its properties
+        visited.add(obj);
+        //get object keys
+        objKeys = Object.keys(obj);
+        //set key output;
+        objKeys.forEach(function(key) {
+            const keyOut = '"' + key + '":';
+            const keyValOut = obj[key];
+            //skip functions and undefined properties
+            if (keyValOut instanceof Function || keyValOut === undefined) return; // Skip this entry entirely instead of pushing an empty string
+            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(1)
+});
+const OptionSchema$1 = zod.z.object({
+    logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+    formatOptions: FormatOptionsSchema.partial().optional().default(DEFAULT_FORMAT_OPTIONS)
+});
+// Type guard to check if an object is a Section
+function isSection(obj) {
+    return obj && typeof obj === 'object' && 'items' in obj && Array.isArray(obj.items);
+}
+// Type guard to check if an object is a Section
+function isWeighted(obj) {
+    return obj && typeof obj === 'object' && 'text' in obj;
+}
+const formatter.create = (formatterOptions)=>{
+    const options = OptionSchema$1.parse(formatterOptions || {});
+    const logger = wrapLogger(options.logger, 'Formatter');
+    let formatOptions = DEFAULT_FORMAT_OPTIONS;
+    if (options === null || options === void 0 ? void 0 : 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 !== null && sectionDepth !== void 0 ? sectionDepth : formatOptions.sectionDepth;
+        logger.silly(`\t\tCurrent section depth: ${currentSectionDepth}`);
+        let result = "";
+        if (isSection(item)) {
+            result = formatSection(item, currentSectionDepth + 1);
+        } else if (isWeighted(item)) {
+            result = item.text;
+        } else {
+            //If the item is neither a section nor a weighted item, it is empty.
+            result = '';
+        }
+        return result;
+    };
+    const formatSection = (section, sectionDepth)=>{
+        logger.silly(`Formatting section`);
+        const currentSectionDepth = sectionDepth !== null && sectionDepth !== void 0 ? sectionDepth : formatOptions.sectionDepth;
+        logger.silly(`\t\tCurrent section depth: ${currentSectionDepth}`);
+        if (section) {
+            const formattedItems = section.items.map((item)=>format(item, currentSectionDepth)).join("\n\n");
+            if (formatOptions.sectionSeparator === "tag") {
+                var _section_title, _section_title1;
+                return `<${(_section_title = section.title) !== null && _section_title !== void 0 ? _section_title : "section"}>\n${formattedItems}\n</${(_section_title1 = section.title) !== null && _section_title1 !== void 0 ? _section_title1 : "section"}>`;
+            } else {
+                // Default depth to 1 if not provided, resulting in H2 (##) matching the test case.
+                const headingLevel = currentSectionDepth;
+                const hashes = '#'.repeat(headingLevel);
+                logger.silly(`\t\tHeading level: ${headingLevel}`);
+                logger.silly(`\t\tSection title: ${section.title}`);
+                return `${hashes} ${formatOptions.sectionTitlePrefix ? `${formatOptions.sectionTitlePrefix} ${formatOptions.sectionTitleSeparator} ` : ""}${section.title}\n\n${formattedItems}`;
+            }
+        } else {
+            return '';
+        }
+    };
+    // Helper function to format arrays of items or sections
+    const formatArray = (items, sectionDepth)=>{
+        logger.silly(`Formatting array`);
+        const currentSectionDepth = sectionDepth !== null && sectionDepth !== void 0 ? 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
+    };
+};
+
+const formatter = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    FormatOptionsSchema,
+    OptionSchema: OptionSchema$1,
+    SectionSeparatorSchema,
+    SectionTitlePropertySchema,
+    create: formatter.create
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const parseMarkdown = (input, options = {})=>{
+    let markdownContent;
+    if (typeof input === 'string') {
+        markdownContent = input;
+    } else {
+        markdownContent = input.toString();
+    }
+    const sectionOptions = section.SectionOptionsSchema.parse(options);
+    // Use marked.lexer to get tokens without full parsing/rendering
+    const tokens = marked.marked.lexer(markdownContent);
+    // Create the main section (with a Title from the options)
+    const mainSection = create$4(sectionOptions);
+    // Track sections at each depth level
+    const sectionStack = [
+        mainSection
+    ];
+    // Set if we've seen the first token
+    let isFirstToken = true;
+    // Set the item options
+    const itemOptions = weighted.WeightedOptionsSchema.parse({
+        ...sectionOptions,
+        weight: sectionOptions.itemWeight
+    });
+    for (const token of tokens){
+        switch(token.type){
+            case 'heading':
+                {
+                    const depth = token.depth;
+                    // If this is the first token and it's a heading, use it as the main section title
+                    if (isFirstToken) {
+                        mainSection.title = token.text;
+                        isFirstToken = false;
+                        break;
+                    }
+                    isFirstToken = false;
+                    // Create a new section with this heading
+                    const newSection = create$4({
+                        ...sectionOptions,
+                        title: token.text
+                    });
+                    // Ensure the section stack has the right size based on this heading's depth
+                    // (e.g., a depth-2 heading should be added to the depth-1 section)
+                    // We need to ensure the stack length is exactly depth, not just less than or equal to depth
+                    while(sectionStack.length > depth && sectionStack.length > 1){
+                        sectionStack.pop();
+                    }
+                    // Make sure we're at the right level for this heading
+                    // If we stay at the same heading level (e.g., two h2s in sequence),
+                    // we need to pop once more to get to the parent level
+                    if (sectionStack.length === depth && sectionStack.length > 1) {
+                        sectionStack.pop();
+                    }
+                    // Add new section to its parent
+                    const parentSection = sectionStack[sectionStack.length - 1];
+                    parentSection.add(newSection, itemOptions);
+                    // Push this section onto the stack
+                    sectionStack.push(newSection);
+                    break;
+                }
+            case 'paragraph':
+                {
+                    isFirstToken = false;
+                    const instruction = create$8(token.text, itemOptions);
+                    const currentSection = sectionStack[sectionStack.length - 1];
+                    currentSection.add(instruction, itemOptions);
+                    break;
+                }
+            case 'list':
+                {
+                    isFirstToken = false;
+                    // Convert list items to instructions
+                    const listInstructionContent = token.items.map((item)=>`- ${item.text}`).join('\n');
+                    const listInstruction = create$8(listInstructionContent, itemOptions);
+                    const currentSection = sectionStack[sectionStack.length - 1];
+                    currentSection.add(listInstruction, itemOptions);
+                    break;
+                }
+            case 'code':
+                {
+                    isFirstToken = false;
+                    // Represent code blocks as instructions
+                    const codeInstruction = create$8(`\`\`\`${token.lang || ''}\n${token.text}\n\`\`\``, itemOptions);
+                    const currentSection = sectionStack[sectionStack.length - 1];
+                    currentSection.add(codeInstruction, itemOptions);
+                    break;
+                }
+            case 'space':
+                break;
+            default:
+                {
+                    isFirstToken = false;
+                    // Treat other block tokens' text as instructions for robustness
+                    if ('text' in token && token.text) {
+                        const fallbackInstruction = create$8(token.text, itemOptions);
+                        const currentSection = sectionStack[sectionStack.length - 1];
+                        currentSection.add(fallbackInstruction, itemOptions);
+                    }
+                    break;
+                }
+        }
+    }
+    return mainSection;
+};
+
+const parseText = (input, options = {})=>{
+    let text;
+    if (typeof input === 'string') {
+        text = input;
+    } else {
+        text = input.toString();
+    }
+    const sectionOptions = section.SectionOptionsSchema.parse(options);
+    // Set the item options
+    const itemOptions = weighted.WeightedOptionsSchema.parse({
+        ...sectionOptions,
+        weight: sectionOptions.itemWeight
+    });
+    // Split the text on newlines
+    const lines = text.split(/\r?\n/).filter((line)=>line.trim().length > 0);
+    // Create the main section with the supplied title
+    const mainSection = create$4(sectionOptions);
+    for (const line of lines){
+        const instruction = create$8(line, itemOptions);
+        mainSection.add(instruction, itemOptions);
+    }
+    return mainSection;
+};
+
+// Heuristic to check for Markdown syntax. This is not a full parser.
+// It looks for common Markdown patterns.
+const markdownRegex = /^(#+\s|\*\s|-\s|\+\s|>\s|\[.*\]\(.*\)|```|~~~|---\\s*$)/m;
+/**
+ * Inspects a string to see if it likely contains Markdown syntax.
+ *
+ * @param input The string or Buffer content to inspect.
+ * @returns True if Markdown syntax is suspected, false otherwise.
+ */ function isMarkdown(input) {
+    if (input == null) {
+        return false;
+    }
+    // Convert Buffer to string if necessary
+    const content = typeof input === 'string' ? input : input.toString(constants.DEFAULT_CHARACTER_ENCODING);
+    if (!content || content.trim() === '') {
+        return false; // Empty string is not considered Markdown
+    }
+    // Check for common Markdown patterns in the entire content
+    if (markdownRegex.test(content)) {
+        return true;
+    }
+    // Fallback: Check for a high prevalence of Markdown-like list/header starters
+    // or thematic breaks, or code blocks.
+    // We'll consider up to the first ~2000 characters, roughly equivalent to the byte check.
+    const effectiveContent = content.length > 2000 ? content.substring(0, 2000) : content;
+    const lines = effectiveContent.split('\n');
+    let markdownFeatureCount = 0;
+    const featurePatterns = [
+        /^#+\s+.+/,
+        /^\s*[*+-]\s+.+/,
+        /^\s*>\s+.+/,
+        /\[.+\]\(.+\)/,
+        /!\[.+\]\(.+\)/,
+        /`{1,3}[^`]+`{1,3}/,
+        /^\s*_{3,}\s*$/,
+        /^\s*-{3,}\s*$/,
+        /^\s*\*{3,}\s*$/
+    ];
+    for (const line of lines){
+        // Stop checking if we have already found enough features to be confident.
+        // This is a small optimization for very long inputs that are clearly markdown early on.
+        if (markdownFeatureCount >= 2 && lines.length > 10) {
+            const significantLineCountEarly = Math.min(lines.indexOf(line) + 1, 20);
+            if (significantLineCountEarly > 0 && markdownFeatureCount / significantLineCountEarly > 0.1) {
+                return true;
+            }
+        }
+        for (const pattern of featurePatterns){
+            if (pattern.test(line.trim())) {
+                markdownFeatureCount++;
+                break; // Count each line only once
+            }
+        }
+    }
+    // If more than 5% of the first few lines (up to 20 lines or all lines if fewer)
+    // show markdown features, or if there are at least 2 distinct features in short texts,
+    // consider it Markdown.
+    const significantLineCount = Math.min(lines.length, 20);
+    if (significantLineCount > 0) {
+        // Calculate the exact threshold percentage
+        const thresholdPercentage = markdownFeatureCount / significantLineCount;
+        // Check against the 5% threshold (0.05)
+        // Using >= 0.05 exactly matches 5%, > 0.05 requires more than 5%
+        if (thresholdPercentage >= 0.05 + 0.0001) {
+            return true;
+        }
+        // Other conditions for returning true
+        if (markdownFeatureCount >= 1 && significantLineCount <= 5 || markdownFeatureCount >= 2) {
+            return true;
+        }
+    }
+    return false;
+} // Example usage (optional, for testing):
+ // function testIsMarkdownString() {
+ //   console.log('--- Testing isMarkdownString ---');
+ //   const markdown1 = '# Hello World\\nThis is a test.';
+ //   console.log(`Test 1 (Header): "${markdown1.substring(0,10)}..." -> ${isMarkdownString(markdown1)}`); // true
+ //   const markdown2 = '* Item 1\\n* Item 2';
+ //   console.log(`Test 2 (List): "${markdown2.substring(0,10)}..." -> ${isMarkdownString(markdown2)}`); // true
+ //   const markdown3 = '[Google](https://google.com)';
+ //   console.log(`Test 3 (Link): "${markdown3.substring(0,15)}..." -> ${isMarkdownString(markdown3)}`); // true
+ //   const markdown4 = '> This is a quote.';
+ //   console.log(`Test 4 (Blockquote): "${markdown4.substring(0,10)}..." -> ${isMarkdownString(markdown4)}`); // true
+ //   const markdown5 = '```javascript\\nconsole.log("hello");\\n```';
+ //   console.log(`Test 5 (Code block): "${markdown5.substring(0,15)}..." -> ${isMarkdownString(markdown5)}`); // true
+ //   const text1 = 'This is a plain text string.';
+ //   console.log(`Test 6 (Plain text): "${text1.substring(0,10)}..." -> ${isMarkdownString(text1)}`); // false
+ //   const text2 = 'hello_world.this_is_a_test_string_with_underscores_but_not_markdown_thematic_break';
+ //   console.log(`Test 7 (Long non-markdown): "${text2.substring(0,10)}..." -> ${isMarkdownString(text2)}`); // false
+ //   const text3 = '<xml><tag>value</tag></xml>';
+ //   console.log(`Test 8 (XML): "${text3.substring(0,10)}..." -> ${isMarkdownString(text3)}`); // false
+ //   const shortMarkdown = '# H';
+ //   console.log(`Test 9 (Short Markdown): "${shortMarkdown}" -> ${isMarkdownString(shortMarkdown)}`); // true
+ //   const shortNonMarkdown = 'Hello';
+ //   console.log(`Test 10 (Short Non-Markdown): "${shortNonMarkdown}" -> ${isMarkdownString(shortNonMarkdown)}`); // false
+ //   const emptyString = '';
+ //   console.log(`Test 11 (Empty string): "" -> ${isMarkdownString(emptyString)}`); // false
+ //   const whitespaceString = '   \t \n  ';
+ //   console.log(`Test 12 (Whitespace string): "${whitespaceString.substring(0,5)}..." -> ${isMarkdownString(whitespaceString)}`); // false
+ //   const markdownWithManyFeatures = `# Title\\n\\n* list\\n* list2\\n\\n> quote here\\n\\n\`\`\`\\ncode\\n\`\`\`\\n\\nnormal text paragraph with a [link](url).\n---\nAnother paragraph.\nThis is just a test string to see how it performs with multiple markdown features present.\nHello world this is a very long line that does not contain any markdown syntax at all, it is just plain text that goes on and on.\n* Another list item\n* And another one\n# Another Header\n## Subheader\nThis is fun.\nOkay I think this is enough.\nFinal line.\nAnother final line.\nOne more for good measure.\nOkay that should be enough lines to test the early exit.\n`;
+ //   console.log(`Test 13 (Many Features): "${markdownWithManyFeatures.substring(0,10)}..." -> ${isMarkdownString(markdownWithManyFeatures)}`); // true
+ //   const htmlLike = '<div><p>Hello</p><ul><li>item</li></ul></div>';
+ //   console.log(`Test 14 (HTML-like): "${htmlLike.substring(0,10)}..." -> ${isMarkdownString(htmlLike)}`); // false
+ //   console.log('--- End Testing ---');
+ // }
+ // testIsMarkdownString();
+
+// Returns true if the input is likely text, false if likely binary
+function isText(input) {
+    let buf;
+    if (typeof input === 'string') {
+        buf = Buffer.from(input, constants.DEFAULT_CHARACTER_ENCODING);
+    } else {
+        buf = input;
+    }
+    // Empty buffers are considered text
+    if (buf.length === 0) {
+        return true;
+    }
+    // If the buffer contains null bytes, it's likely binary
+    if (buf.includes(0)) {
+        return false;
+    }
+    // For UTF-8 encoded text (including emoji and international characters),
+    // convert to string first and check if there are non-printable characters
+    const str = buf.toString(constants.DEFAULT_CHARACTER_ENCODING);
+    // Count the number of non-printable ASCII characters (excluding common whitespace)
+    let nonPrintable = 0;
+    const len = Math.min(str.length, 512); // Only check the first 512 characters for performance
+    for(let i = 0; i < len; i++){
+        const charCode = str.charCodeAt(i);
+        // Allow: tab (9), line feed (10), carriage return (13), printable ASCII (32-126)
+        // Also allow all non-ASCII Unicode characters (charCode > 127)
+        if (charCode !== 9 && charCode !== 10 && charCode !== 13 && (charCode < 32 || charCode > 126 && charCode < 128)) {
+            nonPrintable++;
+        }
+    }
+    // If more than 10% of the checked characters are non-printable, consider it binary
+    return nonPrintable / len < 0.1;
+}
+
+const OptionsSchema$2 = zod.z.object({
+    logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+    parameters: parameters.ParametersSchema.optional().default({})
+});
+const parser.create = (parserOptions)=>{
+    const options = OptionsSchema$2.parse(parserOptions || {});
+    const parameters = options.parameters;
+    const logger = wrapLogger(options.logger, 'Parser');
+    const loadOptions = (sectionOptions = {})=>{
+        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
+        return {
+            ...currentOptions,
+            parameters: {
+                ...parameters,
+                ...currentOptions.parameters
+            }
+        };
+    };
+    const parseFile = async (filePath, options = {})=>{
+        const currentOptions = loadOptions(options);
+        try {
+            const content = await fs__namespace.readFile(filePath, 'utf-8');
+            // Only use the filename as title if no title was explicitly provided
+            const fileName = path__namespace.basename(filePath, path__namespace.extname(filePath));
+            return parse(content, {
+                ...currentOptions,
+                title: (currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.title) || fileName
+            });
+        } catch (error) {
+            // Log the error or handle it appropriately
+            logger.error(`Error reading or parsing file with marked at ${filePath}:`, error);
+            throw new Error(`Failed to parse instructions from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    /**
+     * Reads Markdown content and parses it into a single Section.
+     * 
+     * - If the content starts with a heading, that becomes the title of the returned Section
+     * - If no heading at the start, creates a Section with no title
+     * - Headers within the content create nested sections based on their depth
+     * - All content is organized in a hierarchical structure based on heading levels
+     *
+     * @param content The content to parse
+     * @returns A Section containing all content in a hierarchical structure
+     */ const parse = (content, options = {})=>{
+        const currentOptions = loadOptions(options);
+        let mainSection;
+        if (isMarkdown(content)) {
+            mainSection = parseMarkdown(content, currentOptions);
+        } else if (isText(content)) {
+            mainSection = parseText(content, currentOptions);
+        } else {
+            throw new Error(`Unsupported content supplied to parse, riotprompt currently only supports markdown and text`);
+        }
+        return mainSection;
+    };
+    return {
+        parse,
+        parseFile
+    };
+};
+
+const parser = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create: parser.create
+}, Symbol.toStringTag, { value: 'Module' }));
+
+// eslint-disable-next-line no-restricted-imports
+const create$1 = (params)=>{
+    // eslint-disable-next-line no-console
+    const log = params.log || console.log;
+    const exists = async (path)=>{
+        try {
+            await fs__namespace$1.promises.stat(path);
+            return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path)=>{
+        const stats = await fs__namespace$1.promises.stat(path);
+        if (!stats.isDirectory()) {
+            log(`${path} is not a directory`);
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path)=>{
+        const stats = await fs__namespace$1.promises.stat(path);
+        if (!stats.isFile()) {
+            log(`${path} is not a file`);
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path)=>{
+        try {
+            await fs__namespace$1.promises.access(path, fs__namespace$1.constants.R_OK);
+        } catch (error) {
+            log(`${path} is not readable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path)=>{
+        try {
+            await fs__namespace$1.promises.access(path, fs__namespace$1.constants.W_OK);
+        } catch (error) {
+            log(`${path} is not writable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path)=>{
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path)=>{
+        try {
+            await fs__namespace$1.promises.mkdir(path, {
+                recursive: true
+            });
+        } catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding)=>{
+        return await fs__namespace$1.promises.readFile(path, {
+            encoding: encoding
+        });
+    };
+    const writeFile = async (path, data, encoding)=>{
+        await fs__namespace$1.promises.writeFile(path, data, {
+            encoding: 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 (path)=>{
+        return fs__namespace$1.createReadStream(path);
+    };
+    const hashFile = async (path, length)=>{
+        const file = await readFile(path, 'utf8');
+        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory)=>{
+        return await fs__namespace$1.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        forEachFileIn,
+        hashFile,
+        listFiles
+    };
+};
+
+const OptionsSchema$1 = zod.z.object({
+    logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+    ignorePatterns: zod.z.array(zod.z.string()).optional().default(DEFAULT_IGNORE_PATTERNS),
+    parameters: parameters.ParametersSchema.optional().default({})
+});
+/**
+ * Extracts the first header from Markdown text
+ * @param markdownText The Markdown text to parse
+ * @returns The first header found in the Markdown or null if none is found
+ */ function extractFirstHeader(markdownText) {
+    // Regular expression to match Markdown headers (# Header, ## Header, etc.)
+    const headerRegex = /^(#{1,6})\s+(.+?)(?:\n|$)/m;
+    const match = markdownText.match(headerRegex);
+    if (match && match[2]) {
+        return match[2].trim();
+    }
+    return null;
+}
+/**
+ * Removes the first header from Markdown text
+ * @param markdownText The Markdown text to process
+ * @returns The Markdown text without the first header
+ */ function removeFirstHeader(markdownText) {
+    // Regular expression to match Markdown headers (# Header, ## Header, etc.)
+    const headerRegex = /^(#{1,6})\s+(.+?)(?:\n|$)/m;
+    const match = markdownText.match(headerRegex);
+    if (match) {
+        return markdownText.replace(headerRegex, '').trim();
+    }
+    return markdownText;
+}
+const loader.create = (loaderOptions)=>{
+    const options = OptionsSchema$1.parse(loaderOptions || {});
+    const parameters = options.parameters;
+    const logger = wrapLogger(options.logger, 'Loader');
+    const ignorePatterns = options.ignorePatterns;
+    const loadOptions = (sectionOptions = {})=>{
+        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
+        return {
+            ...currentOptions,
+            parameters: {
+                ...parameters,
+                ...currentOptions.parameters
+            }
+        };
+    };
+    /**
+     * Loads context from the provided directories and returns instruction sections
+     * 
+     * @param contextDirectories Directories containing context files
+     * @returns Array of instruction sections loaded from context directories
+     */ const load = async (contextDirectories = [], options = {})=>{
+        const sectionOptions = loadOptions(options);
+        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
+        });
+        // Add context sections from each directory
+        for (const contextDir of contextDirectories){
+            try {
+                const dirName = path.basename(contextDir);
+                logger.debug(`Processing context directory ${dirName}`);
+                let mainContextSection;
+                // First check if there's a context.md file
+                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');
+                    // Extract the first header from the Markdown content
+                    const firstHeader = extractFirstHeader(mainContextContent);
+                    // Use the header from context.md as the section title, or fallback to directory name
+                    const sectionTitle = firstHeader || dirName;
+                    mainContextSection = create$4({
+                        ...sectionOptions,
+                        title: sectionTitle
+                    });
+                    // Add content without the header
+                    if (firstHeader) {
+                        mainContextSection.add(removeFirstHeader(mainContextContent), {
+                            ...sectionOptions
+                        });
+                    } else {
+                        mainContextSection.add(mainContextContent, {
+                            ...sectionOptions
+                        });
+                    }
+                } else {
+                    // If no context.md exists, use directory name as title
+                    mainContextSection = create$4({
+                        ...sectionOptions,
+                        title: dirName
+                    });
+                }
+                // Get all other files in the directory
+                const files = await storage.listFiles(contextDir);
+                const ignorePatternsRegex = ignorePatterns.map((pattern)=>new RegExp(pattern, 'i'));
+                const filteredFiles = files.filter((file)=>!ignorePatternsRegex.some((regex)=>regex.test(file)));
+                for (const file of filteredFiles){
+                    // Skip the context.md file as it's already processed
+                    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;
+                        // Extract header if it exists
+                        if (file.endsWith('.md')) {
+                            const fileHeader = extractFirstHeader(fileContent);
+                            if (fileHeader) {
+                                sectionName = fileHeader;
+                                // Remove the header from the content
+                                contentToAdd = removeFirstHeader(fileContent);
+                            }
+                        }
+                        // Create a subsection with the extracted name
+                        const fileSection = create$4({
+                            ...sectionOptions,
+                            title: sectionName
+                        });
+                        fileSection.add(contentToAdd, {
+                            ...sectionOptions
+                        });
+                        // Add this file section to the main context section
+                        mainContextSection.add(fileSection, {
+                            ...sectionOptions
+                        });
+                    }
+                }
+                contextSections.push(mainContextSection);
+            } catch (error) {
+                logger.error(`Error processing context directory ${contextDir}: ${error}`);
+            }
+        }
+        return contextSections;
+    };
+    return {
+        load
+    };
+};
+
+const loader = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create: loader.create,
+    extractFirstHeader,
+    removeFirstHeader
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const OptionsSchema = zod.z.object({
+    logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+    configDir: zod.z.string().default('./overrides'),
+    overrides: zod.z.boolean().default(false),
+    parameters: parameters.ParametersSchema.optional().default({})
+});
+const override.create = (overrideOptions = {})=>{
+    const options = OptionsSchema.parse(overrideOptions);
+    const parameters = options.parameters;
+    const logger = wrapLogger(options === null || options === void 0 ? void 0 : options.logger, 'Override');
+    const storage = create$1({
+        log: logger.debug
+    });
+    const loadOptions = (sectionOptions = {})=>{
+        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
+        return {
+            ...currentOptions,
+            parameters: {
+                ...parameters,
+                ...currentOptions.parameters
+            }
+        };
+    };
+    const override = async (overrideFile, section, sectionOptions = {})=>{
+        const currentSectionOptions = loadOptions(sectionOptions);
+        const baseFile = path.join(options.configDir, overrideFile);
+        const preFile = baseFile.replace('.md', '-pre.md');
+        const postFile = baseFile.replace('.md', '-post.md');
+        const response = {};
+        if (await storage.exists(preFile)) {
+            logger.silly('Found pre file %s', preFile);
+            const parser$1 = parser.create({
+                logger
+            });
+            response.prepend = await parser$1.parseFile(preFile, currentSectionOptions);
+        }
+        if (await storage.exists(postFile)) {
+            logger.silly('Found post file %s', postFile);
+            const parser$1 = parser.create({
+                logger
+            });
+            response.append = await parser$1.parseFile(postFile, currentSectionOptions);
+        }
+        if (await storage.exists(baseFile)) {
+            logger.silly('Found base file %s', baseFile);
+            if (options.overrides) {
+                logger.warn('WARNING: Core directives are being overwritten by custom configuration');
+                const parser$1 = parser.create({
+                    logger
+                });
+                response.override = await parser$1.parseFile(baseFile, currentSectionOptions);
+            } else {
+                logger.error('ERROR: Core directives are being overwritten by custom configuration');
+                throw new Error('Core directives are being overwritten by custom configuration, but overrides are not enabled.  Please enable --overrides to use this feature.');
+            }
+        }
+        return response;
+    };
+    const customize = async (overrideFile, section, sectionOptions = {})=>{
+        const currentSectionOptions = loadOptions(sectionOptions);
+        const { overrideContent, prepend, append } = await override(overrideFile, section, currentSectionOptions);
+        let finalSection = section;
+        if (overrideContent) {
+            if (options.overrides) {
+                logger.warn('Override found, replacing content from file %s', overrideContent);
+                finalSection = overrideContent;
+            } else {
+                logger.error('ERROR: Core directives are being overwritten by custom configuration');
+                throw new Error('Core directives are being overwritten by custom configuration, but overrides are not enabled.  Please enable --overrides to use this feature.');
+            }
+        }
+        if (prepend) {
+            logger.silly('Prepend found, adding to content from file %s', prepend);
+            finalSection = finalSection.prepend(prepend);
+        }
+        if (append) {
+            logger.silly('Append found, adding to content from file %s', append);
+            finalSection = finalSection.append(append);
+        }
+        const formatter$1 = formatter.create({
+            logger
+        });
+        logger.silly('Final section %s:\n\n%s\n\n', logger.name, formatter$1.format(finalSection));
+        return finalSection;
+    };
+    return {
+        override,
+        customize
+    };
+};
+
+const override = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create: override.create
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const OptionSchema = zod.z.object({
+    logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+    basePath: zod.z.string(),
+    overridePath: zod.z.string().optional().default("./"),
+    overrides: zod.z.boolean().optional().default(false),
+    parameters: parameters.ParametersSchema.optional().default({})
+});
+const create = (builderOptions)=>{
+    const options = OptionSchema.parse(builderOptions);
+    const logger = wrapLogger(options.logger, 'Builder');
+    const parser$1 = parser.create({
+        logger
+    });
+    const override$1 = override.create({
+        logger,
+        configDir: options.overridePath || "./",
+        overrides: options.overrides || false
+    });
+    const loader$1 = loader.create({
+        logger
+    });
+    const personaSection = create$4({
+        title: "Persona"
+    });
+    const contextSection = create$4({
+        title: "Context"
+    });
+    const instructionSection = create$4({
+        title: "Instruction"
+    });
+    const contentSection = create$4({
+        title: "Content"
+    });
+    const parameters = options.parameters;
+    const instance = {};
+    const loadOptions = (sectionOptions = {})=>{
+        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
+        return {
+            ...currentOptions,
+            parameters: {
+                ...parameters,
+                ...currentOptions.parameters
+            }
+        };
+    };
+    const loadDirectories = async (directories, sectionOptions = {})=>{
+        const currentOptions = loadOptions(sectionOptions);
+        logger.debug("Loading directories", directories);
+        const sections = await loader$1.load(directories, currentOptions);
+        return sections;
+    };
+    const loadContext = async (contextDirectories, sectionOptions = {})=>{
+        const currentOptions = loadOptions(sectionOptions);
+        logger.debug('Loading context', contextDirectories);
+        const context = await loadDirectories(contextDirectories, currentOptions);
+        contextSection.add(context);
+        return instance;
+    };
+    instance.loadContext = loadContext;
+    const loadContent = async (contentDirectories, sectionOptions = {})=>{
+        const currentOptions = loadOptions(sectionOptions);
+        const content = await loadDirectories(contentDirectories, currentOptions);
+        contentSection.add(content);
+        return instance;
+    };
+    instance.loadContent = loadContent;
+    const loadPath = async (contentPath, sectionOptions = {})=>{
+        const currentOptions = loadOptions(sectionOptions);
+        const defaultPath = path.join(options.basePath, contentPath);
+        const section = await parser$1.parseFile(defaultPath, currentOptions);
+        const overrideSection = await override$1.customize(contentPath, section, currentOptions);
+        return overrideSection;
+    };
+    const addPersonaPath = async (contentPath, sectionOptions = {})=>{
+        const currentOptions = loadOptions(sectionOptions);
+        const persona = await loadPath(contentPath, currentOptions);
+        personaSection.add(persona);
+        return instance;
+    };
+    instance.addPersonaPath = addPersonaPath;
+    const addContextPath = async (contentPath, sectionOptions = {})=>{
+        logger.debug("Adding context path", contentPath);
+        const currentOptions = loadOptions(sectionOptions);
+        const context = await loadPath(contentPath, currentOptions);
+        contextSection.add(context);
+        return instance;
+    };
+    instance.addContextPath = addContextPath;
+    const addInstructionPath = async (contentPath, sectionOptions = {})=>{
+        logger.debug("Adding instruction path", contentPath);
+        const currentOptions = loadOptions(sectionOptions);
+        const instruction = await loadPath(contentPath, currentOptions);
+        instructionSection.add(instruction);
+        return instance;
+    };
+    instance.addInstructionPath = addInstructionPath;
+    const addContentPath = async (contentPath, sectionOptions = {})=>{
+        logger.debug("Adding content path", contentPath);
+        const currentOptions = loadOptions(sectionOptions);
+        const content = await loadPath(contentPath, currentOptions);
+        contentSection.add(content);
+        return instance;
+    };
+    instance.addContentPath = addContentPath;
+    const addContent = async (content, sectionOptions = {})=>{
+        logger.debug("Adding content", typeof content);
+        const currentOptions = loadOptions(sectionOptions);
+        const parsedContentSection = parser$1.parse(content, currentOptions);
+        contentSection.add(parsedContentSection);
+        return instance;
+    };
+    instance.addContent = addContent;
+    const addContext = async (context, sectionOptions = {})=>{
+        logger.debug("Adding context", typeof context);
+        const currentOptions = loadOptions(sectionOptions);
+        const parsedContextSection = parser$1.parse(context, currentOptions);
+        contextSection.add(parsedContextSection);
+        return instance;
+    };
+    instance.addContext = addContext;
+    const build = async ()=>{
+        logger.debug("Building prompt", {});
+        const prompt = create$2({
+            persona: personaSection,
+            contexts: contextSection,
+            instructions: instructionSection,
+            contents: contentSection
+        });
+        return prompt;
+    };
+    instance.build = build;
+    return instance;
+};
+
+const builder = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    create
+}, Symbol.toStringTag, { value: 'Module' }));
+
+exports.Builder = builder;
+exports.Chat = chat;
+exports.Formatter = formatter;
+exports.Loader = loader;
+exports.Override = override;
+exports.Parser = parser;
+exports.createContent = create$7;
+exports.createContext = create$6;
+exports.createInstruction = create$5;
+exports.createParameters = create$9;
+exports.createPrompt = create$2;
+exports.createSection = create$4;
+exports.createTrait = create$3;
+exports.createWeighted = create$8;
+//# sourceMappingURL=riotprompt.cjs.map