@riotprompt/riotprompt 0.0.2 → 0.0.4

package/dist/riotprompt.cjs

@@ -5,7 +5,6 @@ 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');
@@ -495,7 +494,9 @@ const formatter = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty(
     create: create$5
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const parseMarkdown = (input, options = {})=>{
+const parseMarkdown = async (input, options = {})=>{
+    // Dynamic import for marked (ES module)
+    const { marked } = await import('marked');
     let markdownContent;
     if (typeof input === 'string') {
         markdownContent = input;
@@ -504,7 +505,7 @@ const parseMarkdown = (input, options = {})=>{
     }
     const sectionOptions = SectionOptionsSchema.parse(options);
     // Use marked.lexer to get tokens without full parsing/rendering
-    const tokens = marked.marked.lexer(markdownContent);
+    const tokens = marked.lexer(markdownContent);
     // Create the main section (with a Title from the options)
     const mainSection = create$8(sectionOptions);
     // Track sections at each depth level
@@ -788,7 +789,7 @@ const create$4 = (parserOptions)=>{
             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, {
+            return await parse(content, {
                 ...currentOptions,
                 title: (currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.title) || fileName
             });
@@ -808,11 +809,11 @@ const create$4 = (parserOptions)=>{
      *
      * @param content The content to parse
      * @returns A Section containing all content in a hierarchical structure
-     */ const parse = (content, options = {})=>{
+     */ const parse = async (content, options = {})=>{
         const currentOptions = loadOptions(options);
         let mainSection;
         if (isMarkdown(content)) {
-            mainSection = parseMarkdown(content, currentOptions);
+            mainSection = await parseMarkdown(content, currentOptions);
         } else if (isText(content)) {
             mainSection = parseText(content, currentOptions);
         } else {
@@ -1111,7 +1112,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 +1137,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 +1195,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 +1225,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 +1239,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({
@@ -1312,7 +1333,7 @@ const create = (builderOptions)=>{
     const addContent = async (content, sectionOptions = {})=>{
         logger.debug("Adding content", typeof content);
         const currentOptions = loadOptions(sectionOptions);
-        const parsedContentSection = parser$1.parse(content, currentOptions);
+        const parsedContentSection = await parser$1.parse(content, currentOptions);
         contentSection.add(parsedContentSection);
         return instance;
     };
@@ -1320,7 +1341,7 @@ const create = (builderOptions)=>{
     const addContext = async (context, sectionOptions = {})=>{
         logger.debug("Adding context", typeof context);
         const currentOptions = loadOptions(sectionOptions);
-        const parsedContextSection = parser$1.parse(context, currentOptions);
+        const parsedContextSection = await parser$1.parse(context, currentOptions);
         contextSection.add(parsedContextSection);
         return instance;
     };
@@ -1344,12 +1365,288 @@ 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
+    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.string().optional()
+});
+// User-customizable template registry
+let TEMPLATES = {};
+/**
+ * Register custom templates with the recipes system
+ * 
+ * @example
+ * ```typescript
+ * // Register your own templates
+ * registerTemplates({
+ *   myWorkflow: {
+ *     persona: { path: "personas/my-persona.md" },
+ *     instructions: [{ path: "instructions/my-instructions.md" }]
+ *   },
+ *   anotherTemplate: {
+ *     persona: { content: "You are a helpful assistant" },
+ *     instructions: [{ content: "Follow these steps..." }]
+ *   }
+ * });
+ * ```
+ */ const registerTemplates = (templates)=>{
+    TEMPLATES = {
+        ...TEMPLATES,
+        ...templates
+    };
+};
+/**
+ * Get currently registered templates
+ */ const getTemplates = ()=>({
+        ...TEMPLATES
+    });
+/**
+ * Clear all registered templates
+ */ const clearTemplates = ()=>{
+    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 = {
+                ...validatedConfig,
+                persona: validatedConfig.persona || template.persona,
+                instructions: [
+                    ...template.instructions || [],
+                    ...validatedConfig.instructions || []
+                ],
+                content: [
+                    ...template.content || [],
+                    ...validatedConfig.content || []
+                ],
+                context: [
+                    ...template.context || [],
+                    ...validatedConfig.context || []
+                ]
+            };
+        }
+    }
+    // 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);
+    }
+};
+// ===== 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,
+    clearTemplates,
+    cook,
+    getTemplates,
+    recipe,
+    registerTemplates
+}, 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.clearTemplates = clearTemplates;
+exports.cook = cook;
 exports.createContent = create$b;
 exports.createContext = create$a;
 exports.createInstruction = create$9;
@@ -1358,4 +1655,7 @@ exports.createPrompt = create$6;
 exports.createSection = create$8;
 exports.createTrait = create$7;
 exports.createWeighted = create$c;
+exports.getTemplates = getTemplates;
+exports.recipe = recipe;
+exports.registerTemplates = registerTemplates;
 //# sourceMappingURL=riotprompt.cjs.map