@riotprompt/riotprompt 0.0.1 → 0.0.3

package/dist/riotprompt.cjs

@@ -31,7 +31,7 @@ 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([
+const ParametersSchema = zod.z.record(zod.z.string(), zod.z.union([
     zod.z.string(),
     zod.z.number(),
     zod.z.boolean(),
@@ -41,7 +41,7 @@ const parameters.ParametersSchema = zod.z.record(zod.z.string(), zod.z.union([
         zod.z.boolean()
     ]))
 ]));
-const create$9 = (parameters)=>{
+const create$d = (parameters)=>{
     return parameters;
 };
 const apply = (text, parameters)=>{
@@ -78,12 +78,12 @@ zod.z.object({
     text: zod.z.string(),
     weight: zod.z.number().optional()
 });
-const weighted.WeightedOptionsSchema = zod.z.object({
+const WeightedOptionsSchema = zod.z.object({
     weight: zod.z.number().optional(),
-    parameters: parameters.ParametersSchema.optional()
+    parameters: ParametersSchema.optional()
 });
-const create$8 = (text, options = {})=>{
-    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
+const create$c = (text, options = {})=>{
+    const weightedOptions = WeightedOptionsSchema.parse(options);
     const parameterizedText = apply(text, weightedOptions.parameters);
     return {
         text: parameterizedText,
@@ -92,36 +92,36 @@ const create$8 = (text, options = {})=>{
 };
 
 // Export create function
-const create$7 = (text, options = {})=>{
-    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
-    return create$8(text, weightedOptions);
+const create$b = (text, options = {})=>{
+    const weightedOptions = WeightedOptionsSchema.parse(options);
+    return create$c(text, weightedOptions);
 };
 
-const create$6 = (text, options = {})=>{
-    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
-    return create$8(text, weightedOptions);
+const create$a = (text, options = {})=>{
+    const weightedOptions = WeightedOptionsSchema.parse(options);
+    return create$c(text, weightedOptions);
 };
 
-const create$5 = (text, options = {})=>{
-    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
-    return create$8(text, weightedOptions);
+const create$9 = (text, options = {})=>{
+    const weightedOptions = WeightedOptionsSchema.parse(options);
+    return create$c(text, weightedOptions);
 };
 
-const section.SectionOptionsSchema = zod.z.object({
+const SectionOptionsSchema = zod.z.object({
     title: zod.z.string().optional(),
     weight: zod.z.number().optional(),
     itemWeight: zod.z.number().optional(),
-    parameters: parameters.ParametersSchema.optional().default({})
+    parameters: ParametersSchema.optional().default({})
 });
-const create$4 = (options = {})=>{
+const create$8 = (options = {})=>{
     const items = [];
-    const sectionOptions = section.SectionOptionsSchema.parse(options);
-    const sectionItemOptions = weighted.WeightedOptionsSchema.parse({
+    const sectionOptions = SectionOptionsSchema.parse(options);
+    const sectionItemOptions = WeightedOptionsSchema.parse({
         ...sectionOptions,
         weight: sectionOptions.itemWeight
     });
     const append = (item, options = {})=>{
-        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        let itemOptions = WeightedOptionsSchema.parse(options);
         itemOptions = {
             ...sectionItemOptions,
             ...itemOptions
@@ -132,15 +132,15 @@ const create$4 = (options = {})=>{
             });
         } else {
             if (typeof item === 'string') {
-                items.push(create$8(item, itemOptions));
+                items.push(create$c(item, itemOptions));
             } else {
                 items.push(item);
             }
         }
-        return section$1;
+        return section;
     };
     const prepend = (item, options = {})=>{
-        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        let itemOptions = WeightedOptionsSchema.parse(options);
         itemOptions = {
             ...sectionItemOptions,
             ...itemOptions
@@ -151,15 +151,15 @@ const create$4 = (options = {})=>{
             });
         } else {
             if (typeof item === 'string') {
-                items.unshift(create$8(item, itemOptions));
+                items.unshift(create$c(item, itemOptions));
             } else {
                 items.unshift(item);
             }
         }
-        return section$1;
+        return section;
     };
     const insert = (index, item, options = {})=>{
-        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        let itemOptions = WeightedOptionsSchema.parse(options);
         itemOptions = {
             ...sectionItemOptions,
             ...itemOptions
@@ -170,39 +170,39 @@ const create$4 = (options = {})=>{
             });
         } else {
             if (typeof item === 'string') {
-                items.splice(index, 0, create$8(item, itemOptions));
+                items.splice(index, 0, create$c(item, itemOptions));
             } else {
                 items.splice(index, 0, item);
             }
         }
-        return section$1;
+        return section;
     };
     const remove = (index)=>{
         items.splice(index, 1);
-        return section$1;
+        return section;
     };
     const replace = (index, item, options = {})=>{
-        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        let itemOptions = WeightedOptionsSchema.parse(options);
         itemOptions = {
             ...sectionItemOptions,
             ...itemOptions
         };
         if (typeof item === 'string') {
-            items[index] = create$8(item, itemOptions);
+            items[index] = create$c(item, itemOptions);
         } else {
             items[index] = item;
         }
-        return section$1;
+        return section;
     };
     const add = (item, options = {})=>{
-        let itemOptions = weighted.WeightedOptionsSchema.parse(options);
+        let itemOptions = WeightedOptionsSchema.parse(options);
         itemOptions = {
             ...sectionItemOptions,
             ...itemOptions
         };
         return append(item, itemOptions);
     };
-    const section$1 = {
+    const section = {
         title: sectionOptions.title,
         items,
         weight: sectionOptions.weight,
@@ -213,15 +213,15 @@ const create$4 = (options = {})=>{
         remove,
         replace
     };
-    return section$1;
+    return section;
 };
 
-const create$3 = (text, options = {})=>{
-    const weightedOptions = weighted.WeightedOptionsSchema.parse(options);
-    return create$8(text, weightedOptions);
+const create$7 = (text, options = {})=>{
+    const weightedOptions = WeightedOptionsSchema.parse(options);
+    return create$c(text, weightedOptions);
 };
 
-const create$2 = ({ persona, instructions, contents, contexts })=>{
+const create$6 = ({ persona, instructions, contents, contexts })=>{
     return {
         persona,
         instructions,
@@ -230,8 +230,8 @@ const create$2 = ({ persona, instructions, contents, contexts })=>{
     };
 };
 
-const constants.DEFAULT_CHARACTER_ENCODING = "utf8";
-const constants.LIBRARY_NAME = "riotprompt";
+const DEFAULT_CHARACTER_ENCODING = "utf8";
+const LIBRARY_NAME = "riotprompt";
 const DEFAULT_PERSONA_ROLE = "developer";
 const DEFAULT_IGNORE_PATTERNS = [
     "^\\..*",
@@ -280,8 +280,10 @@ const DEFAULT_LOGGER = {
     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)
+    // 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 = [
@@ -297,7 +299,7 @@ const wrapLogger = (toWrap, name)=>{
         throw new Error(`Logger is missing required methods: ${missingMethods.join(', ')}`);
     }
     const log = (level, message, ...args)=>{
-        message = `[${constants.LIBRARY_NAME}] ${name ? `[${name}]` : ''}: ${message}`;
+        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);
@@ -389,7 +391,7 @@ function isSection(obj) {
 function isWeighted(obj) {
     return obj && typeof obj === 'object' && 'text' in obj;
 }
-const formatter.create = (formatterOptions)=>{
+const create$5 = (formatterOptions)=>{
     const options = OptionSchema$1.parse(formatterOptions || {});
     const logger = wrapLogger(options.logger, 'Formatter');
     let formatOptions = DEFAULT_FORMAT_OPTIONS;
@@ -490,7 +492,7 @@ const formatter = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty(
     OptionSchema: OptionSchema$1,
     SectionSeparatorSchema,
     SectionTitlePropertySchema,
-    create: formatter.create
+    create: create$5
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const parseMarkdown = (input, options = {})=>{
@@ -500,11 +502,11 @@ const parseMarkdown = (input, options = {})=>{
     } else {
         markdownContent = input.toString();
     }
-    const sectionOptions = section.SectionOptionsSchema.parse(options);
+    const sectionOptions = 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);
+    const mainSection = create$8(sectionOptions);
     // Track sections at each depth level
     const sectionStack = [
         mainSection
@@ -512,7 +514,7 @@ const parseMarkdown = (input, options = {})=>{
     // Set if we've seen the first token
     let isFirstToken = true;
     // Set the item options
-    const itemOptions = weighted.WeightedOptionsSchema.parse({
+    const itemOptions = WeightedOptionsSchema.parse({
         ...sectionOptions,
         weight: sectionOptions.itemWeight
     });
@@ -529,7 +531,7 @@ const parseMarkdown = (input, options = {})=>{
                     }
                     isFirstToken = false;
                     // Create a new section with this heading
-                    const newSection = create$4({
+                    const newSection = create$8({
                         ...sectionOptions,
                         title: token.text
                     });
@@ -555,7 +557,7 @@ const parseMarkdown = (input, options = {})=>{
             case 'paragraph':
                 {
                     isFirstToken = false;
-                    const instruction = create$8(token.text, itemOptions);
+                    const instruction = create$c(token.text, itemOptions);
                     const currentSection = sectionStack[sectionStack.length - 1];
                     currentSection.add(instruction, itemOptions);
                     break;
@@ -565,7 +567,7 @@ const parseMarkdown = (input, options = {})=>{
                     isFirstToken = false;
                     // Convert list items to instructions
                     const listInstructionContent = token.items.map((item)=>`- ${item.text}`).join('\n');
-                    const listInstruction = create$8(listInstructionContent, itemOptions);
+                    const listInstruction = create$c(listInstructionContent, itemOptions);
                     const currentSection = sectionStack[sectionStack.length - 1];
                     currentSection.add(listInstruction, itemOptions);
                     break;
@@ -574,7 +576,7 @@ const parseMarkdown = (input, options = {})=>{
                 {
                     isFirstToken = false;
                     // Represent code blocks as instructions
-                    const codeInstruction = create$8(`\`\`\`${token.lang || ''}\n${token.text}\n\`\`\``, itemOptions);
+                    const codeInstruction = create$c(`\`\`\`${token.lang || ''}\n${token.text}\n\`\`\``, itemOptions);
                     const currentSection = sectionStack[sectionStack.length - 1];
                     currentSection.add(codeInstruction, itemOptions);
                     break;
@@ -586,7 +588,7 @@ const parseMarkdown = (input, options = {})=>{
                     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 fallbackInstruction = create$c(token.text, itemOptions);
                         const currentSection = sectionStack[sectionStack.length - 1];
                         currentSection.add(fallbackInstruction, itemOptions);
                     }
@@ -604,18 +606,18 @@ const parseText = (input, options = {})=>{
     } else {
         text = input.toString();
     }
-    const sectionOptions = section.SectionOptionsSchema.parse(options);
+    const sectionOptions = SectionOptionsSchema.parse(options);
     // Set the item options
-    const itemOptions = weighted.WeightedOptionsSchema.parse({
+    const itemOptions = 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);
+    const mainSection = create$8(sectionOptions);
     for (const line of lines){
-        const instruction = create$8(line, itemOptions);
+        const instruction = create$c(line, itemOptions);
         mainSection.add(instruction, itemOptions);
     }
     return mainSection;
@@ -634,7 +636,7 @@ const markdownRegex = /^(#+\s|\*\s|-\s|\+\s|>\s|\[.*\]\(.*\)|```|~~~|---\\s*$)/m
         return false;
     }
     // Convert Buffer to string if necessary
-    const content = typeof input === 'string' ? input : input.toString(constants.DEFAULT_CHARACTER_ENCODING);
+    const content = typeof input === 'string' ? input : input.toString(DEFAULT_CHARACTER_ENCODING);
     if (!content || content.trim() === '') {
         return false; // Empty string is not considered Markdown
     }
@@ -732,7 +734,7 @@ const markdownRegex = /^(#+\s|\*\s|-\s|\+\s|>\s|\[.*\]\(.*\)|```|~~~|---\\s*$)/m
 function isText(input) {
     let buf;
     if (typeof input === 'string') {
-        buf = Buffer.from(input, constants.DEFAULT_CHARACTER_ENCODING);
+        buf = Buffer.from(input, DEFAULT_CHARACTER_ENCODING);
     } else {
         buf = input;
     }
@@ -746,7 +748,7 @@ function isText(input) {
     }
     // 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);
+    const str = buf.toString(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
@@ -764,14 +766,14 @@ function isText(input) {
 
 const OptionsSchema$2 = zod.z.object({
     logger: zod.z.any().optional().default(DEFAULT_LOGGER),
-    parameters: parameters.ParametersSchema.optional().default({})
+    parameters: ParametersSchema.optional().default({})
 });
-const parser.create = (parserOptions)=>{
+const create$4 = (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);
+        const currentOptions = SectionOptionsSchema.parse(sectionOptions);
         return {
             ...currentOptions,
             parameters: {
@@ -826,11 +828,11 @@ const parser.create = (parserOptions)=>{
 
 const parser = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
-    create: parser.create
+    create: create$4
 }, Symbol.toStringTag, { value: 'Module' }));
 
 // eslint-disable-next-line no-restricted-imports
-const create$1 = (params)=>{
+const create$3 = (params)=>{
     // eslint-disable-next-line no-console
     const log = params.log || console.log;
     const exists = async (path)=>{
@@ -957,7 +959,7 @@ const create$1 = (params)=>{
 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({})
+    parameters: ParametersSchema.optional().default({})
 });
 /**
  * Extracts the first header from Markdown text
@@ -985,13 +987,13 @@ const OptionsSchema$1 = zod.z.object({
     }
     return markdownText;
 }
-const loader.create = (loaderOptions)=>{
+const create$2 = (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);
+        const currentOptions = SectionOptionsSchema.parse(sectionOptions);
         return {
             ...currentOptions,
             parameters: {
@@ -1013,7 +1015,7 @@ const loader.create = (loaderOptions)=>{
             logger.debug(`No context directories provided, returning empty context`);
             return contextSections;
         }
-        const storage = create$1({
+        const storage = create$3({
             log: logger.debug
         });
         // Add context sections from each directory
@@ -1031,7 +1033,7 @@ const loader.create = (loaderOptions)=>{
                     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({
+                    mainContextSection = create$8({
                         ...sectionOptions,
                         title: sectionTitle
                     });
@@ -1047,7 +1049,7 @@ const loader.create = (loaderOptions)=>{
                     }
                 } else {
                     // If no context.md exists, use directory name as title
-                    mainContextSection = create$4({
+                    mainContextSection = create$8({
                         ...sectionOptions,
                         title: dirName
                     });
@@ -1075,7 +1077,7 @@ const loader.create = (loaderOptions)=>{
                             }
                         }
                         // Create a subsection with the extracted name
-                        const fileSection = create$4({
+                        const fileSection = create$8({
                             ...sectionOptions,
                             title: sectionName
                         });
@@ -1102,26 +1104,28 @@ const loader.create = (loaderOptions)=>{
 
 const loader = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
-    create: loader.create,
+    create: create$2,
     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'),
+    configDirs: zod.z.array(zod.z.string()).default([
+        './overrides'
+    ]),
     overrides: zod.z.boolean().default(false),
-    parameters: parameters.ParametersSchema.optional().default({})
+    parameters: ParametersSchema.optional().default({})
 });
-const override.create = (overrideOptions = {})=>{
+const create$1 = (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({
+    const storage = create$3({
         log: logger.debug
     });
     const loadOptions = (sectionOptions = {})=>{
-        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
+        const currentOptions = SectionOptionsSchema.parse(sectionOptions);
         return {
             ...currentOptions,
             parameters: {
@@ -1132,42 +1136,54 @@ const override.create = (overrideOptions = {})=>{
     };
     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({
+        const response = {
+            prepends: [],
+            appends: []
+        };
+        // Process directories in order (closest to furthest)
+        for(let i = 0; i < options.configDirs.length; i++){
+            const configDir = options.configDirs[i];
+            const baseFile = path.join(configDir, overrideFile);
+            const preFile = baseFile.replace('.md', '-pre.md');
+            const postFile = baseFile.replace('.md', '-post.md');
+            // Check for prepend files (-pre.md)
+            if (await storage.exists(preFile)) {
+                logger.silly('Found pre file %s (layer %d)', preFile, i + 1);
+                const parser$1 = create$4({
                     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.');
+                const prependSection = await parser$1.parseFile(preFile, currentSectionOptions);
+                response.prepends.push(prependSection);
+            }
+            // Check for append files (-post.md)
+            if (await storage.exists(postFile)) {
+                logger.silly('Found post file %s (layer %d)', postFile, i + 1);
+                const parser$1 = create$4({
+                    logger
+                });
+                const appendSection = await parser$1.parseFile(postFile, currentSectionOptions);
+                response.appends.push(appendSection);
+            }
+            // Check for complete override files - use the first (closest) one found
+            if (!response.override && await storage.exists(baseFile)) {
+                logger.silly('Found base file %s (layer %d)', baseFile, i + 1);
+                if (options.overrides) {
+                    logger.warn('WARNING: Core directives are being overwritten by custom configuration at layer %d', i + 1);
+                    const parser$1 = create$4({
+                        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);
+        const { override: overrideContent, prepends, appends } = await override(overrideFile, section, currentSectionOptions);
         let finalSection = section;
         if (overrideContent) {
             if (options.overrides) {
@@ -1178,15 +1194,17 @@ const override.create = (overrideOptions = {})=>{
                 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) {
+        // Apply prepends in order (closest layer first)
+        for (const prepend of prepends){
             logger.silly('Prepend found, adding to content from file %s', prepend);
             finalSection = finalSection.prepend(prepend);
         }
-        if (append) {
+        // Apply appends in reverse order (furthest layers first, then closest)
+        for (const append of appends.reverse()){
             logger.silly('Append found, adding to content from file %s', append);
             finalSection = finalSection.append(append);
         }
-        const formatter$1 = formatter.create({
+        const formatter$1 = create$5({
             logger
         });
         logger.silly('Final section %s:\n\n%s\n\n', logger.name, formatter$1.format(finalSection));
@@ -1200,46 +1218,50 @@ const override.create = (overrideOptions = {})=>{
 
 const override = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
-    create: override.create
+    create: create$1
 }, 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("./"),
+    overridePaths: zod.z.array(zod.z.string()).optional().default([
+        "./"
+    ]),
     overrides: zod.z.boolean().optional().default(false),
-    parameters: parameters.ParametersSchema.optional().default({})
+    parameters: ParametersSchema.optional().default({})
 });
 const create = (builderOptions)=>{
     const options = OptionSchema.parse(builderOptions);
     const logger = wrapLogger(options.logger, 'Builder');
-    const parser$1 = parser.create({
+    const parser$1 = create$4({
         logger
     });
-    const override$1 = override.create({
+    const override$1 = create$1({
         logger,
-        configDir: options.overridePath || "./",
+        configDirs: options.overridePaths || [
+            "./"
+        ],
         overrides: options.overrides || false
     });
-    const loader$1 = loader.create({
+    const loader$1 = create$2({
         logger
     });
-    const personaSection = create$4({
+    const personaSection = create$8({
         title: "Persona"
     });
-    const contextSection = create$4({
+    const contextSection = create$8({
         title: "Context"
     });
-    const instructionSection = create$4({
+    const instructionSection = create$8({
         title: "Instruction"
     });
-    const contentSection = create$4({
+    const contentSection = create$8({
         title: "Content"
     });
     const parameters = options.parameters;
     const instance = {};
     const loadOptions = (sectionOptions = {})=>{
-        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
+        const currentOptions = SectionOptionsSchema.parse(sectionOptions);
         return {
             ...currentOptions,
             parameters: {
@@ -1325,7 +1347,7 @@ const create = (builderOptions)=>{
     instance.addContext = addContext;
     const build = async ()=>{
         logger.debug("Building prompt", {});
-        const prompt = create$2({
+        const prompt = create$6({
             persona: personaSection,
             contexts: contextSection,
             instructions: instructionSection,
@@ -1342,18 +1364,450 @@ const builder = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     create
 }, Symbol.toStringTag, { value: 'Module' }));
 
+// ===== CONFIGURATION SCHEMAS =====
+const ContentItemSchema = zod.z.union([
+    zod.z.string(),
+    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()
+    })
+]);
+const RecipeConfigSchema = 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 - smart inference based on naming
+    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(),
+    template: zod.z.enum([
+        'commit',
+        'release',
+        'documentation',
+        'review',
+        'custom'
+    ]).optional()
+});
+// Built-in template configurations matching common patterns
+const DEFAULT_TEMPLATES = {
+    commit: {
+        persona: {
+            path: "personas/developer.md",
+            title: "Developer Persona"
+        },
+        instructions: [
+            {
+                path: "instructions/commit.md",
+                title: "Commit Instructions"
+            }
+        ]
+    },
+    release: {
+        persona: {
+            path: "personas/releaser.md",
+            title: "Release Manager Persona"
+        },
+        instructions: [
+            {
+                path: "instructions/release.md",
+                title: "Release Instructions"
+            }
+        ]
+    },
+    documentation: {
+        persona: {
+            path: "personas/technical-writer.md",
+            title: "Technical Writer Persona"
+        },
+        instructions: [
+            {
+                path: "instructions/documentation.md",
+                title: "Documentation Instructions"
+            }
+        ]
+    },
+    review: {
+        persona: {
+            path: "personas/reviewer.md",
+            title: "Code Reviewer Persona"
+        },
+        instructions: [
+            {
+                path: "instructions/review.md",
+                title: "Review Instructions"
+            }
+        ]
+    }
+};
+// User-customizable template registry
+let TEMPLATES = {
+    ...DEFAULT_TEMPLATES
+};
+/**
+ * Configure custom template paths (perfect for KodrDriv constants!)
+ * 
+ * @example
+ * ```typescript
+ * // Configure using your KodrDriv constants
+ * configureTemplates({
+ *   commit: {
+ *     persona: { path: DEFAULT_PERSONA_YOU_FILE },
+ *     instructions: [{ path: DEFAULT_INSTRUCTIONS_COMMIT_FILE }]
+ *   },
+ *   release: {
+ *     persona: { path: DEFAULT_PERSONA_RELEASER_FILE },
+ *     instructions: [{ path: DEFAULT_INSTRUCTIONS_RELEASE_FILE }]
+ *   }
+ * });
+ * ```
+ */ const configureTemplates = (customTemplates)=>{
+    TEMPLATES = {
+        ...DEFAULT_TEMPLATES,
+        ...customTemplates
+    };
+};
+/**
+ * Get current template configuration
+ */ const getTemplates = ()=>({
+        ...TEMPLATES
+    });
+// ===== CORE RECIPE ENGINE =====
+const cook = async (config)=>{
+    // Parse and validate configuration with defaults
+    const validatedConfig = RecipeConfigSchema.parse({
+        overridePaths: [
+            "./"
+        ],
+        overrides: false,
+        parameters: {},
+        instructions: [],
+        content: [],
+        context: [],
+        ...config
+    });
+    // Handle template inheritance
+    let finalConfig = {
+        ...validatedConfig
+    };
+    if (validatedConfig.template) {
+        const template = TEMPLATES[validatedConfig.template];
+        if (template) {
+            finalConfig = {
+                ...template,
+                ...validatedConfig
+            };
+        }
+    }
+    // Setup internal services
+    const logger = wrapLogger(finalConfig.logger, 'Recipe');
+    const parser$1 = create$4({
+        logger
+    });
+    const override$1 = create$1({
+        logger,
+        configDirs: finalConfig.overridePaths || [
+            "./"
+        ],
+        overrides: finalConfig.overrides || false
+    });
+    const loader$1 = create$2({
+        logger
+    });
+    // Create sections
+    const personaSection = create$8({
+        title: "Persona"
+    });
+    const instructionSection = create$8({
+        title: "Instruction"
+    });
+    const contentSection = create$8({
+        title: "Content"
+    });
+    const contextSection = create$8({
+        title: "Context"
+    });
+    // Process persona
+    if (finalConfig.persona) {
+        await processContentItem(finalConfig.persona, personaSection, 'persona', {
+            basePath: finalConfig.basePath,
+            parser: parser$1,
+            override: override$1,
+            loader: loader$1,
+            parameters: finalConfig.parameters});
+    }
+    // Process instructions
+    for (const item of finalConfig.instructions || []){
+        await processContentItem(item, instructionSection, 'instruction', {
+            basePath: finalConfig.basePath,
+            parser: parser$1,
+            override: override$1,
+            loader: loader$1,
+            parameters: finalConfig.parameters});
+    }
+    // Process content
+    for (const item of finalConfig.content || []){
+        await processContentItem(item, contentSection, 'content', {
+            basePath: finalConfig.basePath,
+            parser: parser$1,
+            override: override$1,
+            loader: loader$1,
+            parameters: finalConfig.parameters});
+    }
+    // Process context
+    for (const item of finalConfig.context || []){
+        await processContentItem(item, contextSection, 'context', {
+            basePath: finalConfig.basePath,
+            parser: parser$1,
+            override: override$1,
+            loader: loader$1,
+            parameters: finalConfig.parameters});
+    }
+    // Build and return prompt
+    return create$6({
+        persona: personaSection,
+        instructions: instructionSection,
+        contents: contentSection,
+        contexts: contextSection
+    });
+};
+const processContentItem = async (item, section, type, ctx)=>{
+    const sectionOptions = {
+        parameters: ctx.parameters
+    };
+    if (typeof item === 'string') {
+        // Simple string content
+        const parsedSection = ctx.parser.parse(item, sectionOptions);
+        section.add(parsedSection);
+    } else if ('content' in item) {
+        // Inline content with options
+        const parsedSection = ctx.parser.parse(item.content, {
+            ...sectionOptions,
+            title: item.title,
+            weight: item.weight
+        });
+        section.add(parsedSection);
+    } else if ('path' in item) {
+        // File path
+        const fullPath = path.join(ctx.basePath, item.path);
+        const parsedSection = await ctx.parser.parseFile(fullPath, {
+            ...sectionOptions,
+            title: item.title,
+            weight: item.weight
+        });
+        const overrideSection = await ctx.override.customize(item.path, parsedSection, sectionOptions);
+        section.add(overrideSection);
+    } else if ('directories' in item) {
+        // Directory loading
+        const sections = await ctx.loader.load(item.directories, {
+            ...sectionOptions,
+            title: item.title,
+            weight: item.weight
+        });
+        section.add(sections);
+    }
+};
+// ===== CONVENIENCE FUNCTIONS =====
+const commit = (config)=>cook({
+        ...config,
+        template: 'commit'
+    });
+const release = (config)=>cook({
+        ...config,
+        template: 'release'
+    });
+const documentation = (config)=>cook({
+        ...config,
+        template: 'documentation'
+    });
+const review = (config)=>cook({
+        ...config,
+        template: 'review'
+    });
+// ===== QUICK BUILDERS =====
+const quick = {
+    /**
+   * Create a commit prompt with minimal configuration
+   */ commit: async (diffContent, options)=>{
+        return cook({
+            basePath: options.basePath,
+            overridePaths: options.overridePaths,
+            overrides: options.overrides,
+            template: 'commit',
+            content: [
+                ...options.userDirection ? [
+                    {
+                        content: options.userDirection,
+                        title: 'User Direction',
+                        weight: 1.0
+                    }
+                ] : [],
+                {
+                    content: diffContent,
+                    title: 'Diff',
+                    weight: 0.5
+                }
+            ],
+            context: [
+                ...options.context ? [
+                    {
+                        content: options.context,
+                        title: 'User Context',
+                        weight: 1.0
+                    }
+                ] : [],
+                ...options.directories ? [
+                    {
+                        directories: options.directories,
+                        weight: 0.5
+                    }
+                ] : []
+            ]
+        });
+    },
+    /**
+   * Create a release prompt with minimal configuration
+   */ release: async (logContent, diffContent, options)=>{
+        return cook({
+            basePath: options.basePath,
+            overridePaths: options.overridePaths,
+            overrides: options.overrides,
+            template: 'release',
+            content: [
+                ...options.releaseFocus ? [
+                    {
+                        content: options.releaseFocus,
+                        title: 'Release Focus',
+                        weight: 1.0
+                    }
+                ] : [],
+                {
+                    content: logContent,
+                    title: 'Log',
+                    weight: 0.5
+                },
+                {
+                    content: diffContent,
+                    title: 'Diff',
+                    weight: 0.5
+                }
+            ],
+            context: [
+                ...options.context ? [
+                    {
+                        content: options.context,
+                        title: 'User Context',
+                        weight: 1.0
+                    }
+                ] : [],
+                ...options.directories ? [
+                    {
+                        directories: options.directories,
+                        weight: 0.5
+                    }
+                ] : []
+            ]
+        });
+    }
+};
+// ===== FLUENT RECIPE BUILDER =====
+const recipe = (basePath)=>({
+        template: (name)=>({
+                with: (config)=>cook({
+                        basePath,
+                        template: name,
+                        ...config
+                    })
+            }),
+        persona: (persona)=>({
+                instructions: (...instructions)=>({
+                        content: (...content)=>({
+                                context: (...context)=>({
+                                        cook: ()=>cook({
+                                                basePath,
+                                                persona,
+                                                instructions,
+                                                content,
+                                                context
+                                            })
+                                    }),
+                                cook: ()=>cook({
+                                        basePath,
+                                        persona,
+                                        instructions,
+                                        content
+                                    })
+                            }),
+                        cook: ()=>cook({
+                                basePath,
+                                persona,
+                                instructions
+                            })
+                    }),
+                cook: ()=>cook({
+                        basePath,
+                        persona
+                    })
+            }),
+        cook: (config)=>cook({
+                basePath,
+                ...config
+            })
+    });
+
+const recipes = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    commit,
+    configureTemplates,
+    cook,
+    documentation,
+    getTemplates,
+    quick,
+    recipe,
+    release,
+    review
+}, 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;
+exports.Recipes = recipes;
+exports.commit = commit;
+exports.configureTemplates = configureTemplates;
+exports.cook = cook;
+exports.createContent = create$b;
+exports.createContext = create$a;
+exports.createInstruction = create$9;
+exports.createParameters = create$d;
+exports.createPrompt = create$6;
+exports.createSection = create$8;
+exports.createTrait = create$7;
+exports.createWeighted = create$c;
+exports.documentation = documentation;
+exports.getTemplates = getTemplates;
+exports.quick = quick;
+exports.recipe = recipe;
+exports.release = release;
+exports.review = review;
 //# sourceMappingURL=riotprompt.cjs.map