@riotprompt/riotprompt 0.0.2 → 0.0.3

package/dist/riotprompt.cjs

@@ -1111,7 +1111,9 @@ const loader = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 
 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: ParametersSchema.optional().default({})
 });
@@ -1134,42 +1136,54 @@ const create$1 = (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 = create$4({
-                logger
-            });
-            response.prepend = await parser$1.parseFile(preFile, currentSectionOptions);
-        }
-        if (await storage.exists(postFile)) {
-            logger.silly('Found post file %s', postFile);
-            const parser$1 = create$4({
-                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 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) {
@@ -1180,11 +1194,13 @@ const create$1 = (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);
         }
@@ -1208,7 +1224,9 @@ const override = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 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: ParametersSchema.optional().default({})
 });
@@ -1220,7 +1238,9 @@ const create = (builderOptions)=>{
     });
     const override$1 = create$1({
         logger,
-        configDir: options.overridePath || "./",
+        configDirs: options.overridePaths || [
+            "./"
+        ],
         overrides: options.overrides || false
     });
     const loader$1 = create$2({
@@ -1344,12 +1364,438 @@ 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.Recipes = recipes;
+exports.commit = commit;
+exports.configureTemplates = configureTemplates;
+exports.cook = cook;
 exports.createContent = create$b;
 exports.createContext = create$a;
 exports.createInstruction = create$9;
@@ -1358,4 +1804,10 @@ 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