@riotprompt/riotprompt 0.0.3 → 0.0.6

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');
@@ -202,6 +201,16 @@ const create$8 = (options = {})=>{
         };
         return append(item, itemOptions);
     };
+    const toJSON = ()=>{
+        return {
+            title: section.title,
+            items: items.map((item)=>{
+                // If the item has a toJSON method, call it, otherwise return the item itself
+                return typeof item === 'object' && item !== null && 'toJSON' in item && typeof item.toJSON === 'function' ? item.toJSON() : item;
+            }),
+            weight: section.weight
+        };
+    };
     const section = {
         title: sectionOptions.title,
         items,
@@ -211,7 +220,8 @@ const create$8 = (options = {})=>{
         prepend,
         insert,
         remove,
-        replace
+        replace,
+        toJSON
     };
     return section;
 };
@@ -495,7 +505,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 +516,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 +800,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 +820,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 {
@@ -1332,7 +1344,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;
     };
@@ -1340,7 +1352,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;
     };
@@ -1392,104 +1404,50 @@ const RecipeConfigSchema = zod.z.object({
     ]),
     overrides: zod.z.boolean().optional().default(false),
     parameters: ParametersSchema.optional().default({}),
-    // Content sections - smart inference based on naming
+    // 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.enum([
-        'commit',
-        'release',
-        'documentation',
-        'review',
-        'custom'
-    ]).optional()
+    template: zod.z.string().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
-};
+let TEMPLATES = {};
 /**
- * Configure custom template paths (perfect for KodrDriv constants!)
+ * Register custom templates with the recipes system
  * 
  * @example
  * ```typescript
- * // Configure using your KodrDriv constants
- * configureTemplates({
- *   commit: {
- *     persona: { path: DEFAULT_PERSONA_YOU_FILE },
- *     instructions: [{ path: DEFAULT_INSTRUCTIONS_COMMIT_FILE }]
+ * // Register your own templates
+ * registerTemplates({
+ *   myWorkflow: {
+ *     persona: { path: "personas/my-persona.md" },
+ *     instructions: [{ path: "instructions/my-instructions.md" }]
  *   },
- *   release: {
- *     persona: { path: DEFAULT_PERSONA_RELEASER_FILE },
- *     instructions: [{ path: DEFAULT_INSTRUCTIONS_RELEASE_FILE }]
+ *   anotherTemplate: {
+ *     persona: { content: "You are a helpful assistant" },
+ *     instructions: [{ content: "Follow these steps..." }]
  *   }
  * });
  * ```
- */ const configureTemplates = (customTemplates)=>{
+ */ const registerTemplates = (templates)=>{
     TEMPLATES = {
-        ...DEFAULT_TEMPLATES,
-        ...customTemplates
+        ...TEMPLATES,
+        ...templates
     };
 };
 /**
- * Get current template configuration
+ * 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
@@ -1512,8 +1470,20 @@ const cook = async (config)=>{
         const template = TEMPLATES[validatedConfig.template];
         if (template) {
             finalConfig = {
-                ...template,
-                ...validatedConfig
+                ...validatedConfig,
+                persona: validatedConfig.persona || template.persona,
+                instructions: [
+                    ...template.instructions || [],
+                    ...validatedConfig.instructions || []
+                ],
+                content: [
+                    ...template.content || [],
+                    ...validatedConfig.content || []
+                ],
+                context: [
+                    ...template.context || [],
+                    ...validatedConfig.context || []
+                ]
             };
         }
     }
@@ -1564,7 +1534,10 @@ const cook = async (config)=>{
             parameters: finalConfig.parameters});
     }
     // Process content
+    // eslint-disable-next-line no-console
     for (const item of finalConfig.content || []){
+        // eslint-disable-next-line no-console
+        console.log('Processing content item:', JSON.stringify(item, null, 2));
         await processContentItem(item, contentSection, 'content', {
             basePath: finalConfig.basePath,
             parser: parser$1,
@@ -1595,11 +1568,11 @@ const processContentItem = async (item, section, type, ctx)=>{
     };
     if (typeof item === 'string') {
         // Simple string content
-        const parsedSection = ctx.parser.parse(item, sectionOptions);
+        const parsedSection = await ctx.parser.parse(item, sectionOptions);
         section.add(parsedSection);
     } else if ('content' in item) {
         // Inline content with options
-        const parsedSection = ctx.parser.parse(item.content, {
+        const parsedSection = await ctx.parser.parse(item.content, {
             ...sectionOptions,
             title: item.title,
             weight: item.weight
@@ -1625,165 +1598,72 @@ const processContentItem = async (item, section, type, ctx)=>{
         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 recipe = (basePath)=>{
+    const config = {
+        basePath
+    };
+    const builder = {
+        template: (name)=>{
+            config.template = name;
+            return builder;
+        },
+        with: (partialConfig)=>{
+            Object.assign(config, partialConfig);
+            return builder;
+        },
+        persona: (persona)=>{
+            config.persona = persona;
+            return builder;
+        },
+        instructions: (...instructions)=>{
+            config.instructions = [
+                ...config.instructions || [],
+                ...instructions
+            ];
+            return builder;
+        },
+        content: (...content)=>{
+            config.content = [
+                ...config.content || [],
+                ...content
+            ];
+            return builder;
+        },
+        context: (...context)=>{
+            config.context = [
+                ...config.context || [],
+                ...context
+            ];
+            return builder;
+        },
+        parameters: (parameters)=>{
+            config.parameters = {
+                ...config.parameters,
+                ...parameters
+            };
+            return builder;
+        },
+        overrides: (enabled)=>{
+            config.overrides = enabled;
+            return builder;
+        },
+        overridePaths: (paths)=>{
+            config.overridePaths = paths;
+            return builder;
+        },
+        cook: ()=>cook(config)
+    };
+    return builder;
+};
 
 const recipes = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
-    commit,
-    configureTemplates,
+    clearTemplates,
     cook,
-    documentation,
     getTemplates,
-    quick,
     recipe,
-    release,
-    review
+    registerTemplates
 }, Symbol.toStringTag, { value: 'Module' }));
 
 exports.Builder = builder;
@@ -1793,8 +1673,7 @@ exports.Loader = loader;
 exports.Override = override;
 exports.Parser = parser;
 exports.Recipes = recipes;
-exports.commit = commit;
-exports.configureTemplates = configureTemplates;
+exports.clearTemplates = clearTemplates;
 exports.cook = cook;
 exports.createContent = create$b;
 exports.createContext = create$a;
@@ -1804,10 +1683,7 @@ 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;
+exports.registerTemplates = registerTemplates;
 //# sourceMappingURL=riotprompt.cjs.map