- replaced *.hbs with *.md for actions code syntax highlighting

- added support for ':pre' template execution code script blocks
- added input text classification into a suitable action template
- added support for running nodejs pre code blocks and returning data chaining between code blocks
- added 2/3 functioning write-readme action

Author: puntorigen

actions/create-react-website.hbs actions/create-react-website.md

@@ -2,16 +2,17 @@
 Creates a reactJS webapp project.
 ```
 
-```pre:js 
+```js:pre 
 // javascript code to run on project before executing the template prompt
 // contains a 'context' object with the keys:
 //  'input' = user input text prompt
 // if you want, you may return an object to make the values available for the next code-block or template
 // this codeblock gets executed isolated within an async function
+// you can also use any of the variables available on the handlebar template such as source_tree, absolute_code_path, etc
 // you also have some methods for asking info to the user like (await prompt)
 // anything queried to the user is translated to the user's language using the LLM
 const project_name = await prompt('What is the name of your project?')
-const app_name = await queryLLM('Create a short folder name (max 10 chars without spaces) for the following text: ' + project_name, 
+const app_name = await queryLLM('Create a short but meaningful folder name (between 8-12 chars, dash-case, lowercase) extracted from the following text: ' + project_name, 
     z.object({
         name: z.string().describe('the reactjs folder name for the text'),
     })
@@ -21,7 +22,7 @@ return {
 }
 ```
 
-```pre:bash
+```bash:pre
 # terminal commands to run on project before executing the template prompt
 # if OS is different than MacOS we could ask the LLM for translating them to another OS later before execution
 # any bash here executes with the env CI=true so it won't prompt the user for anything

actions/default.hbs actions/default.md

@@ -1,4 +1,4 @@
-// read all .hbs files in the current directory
+// read all .md files in the current directory
 // parse the md code-blocks looking for 'description' lang field blocks
 // create a prompt for the CLI to choose the best action template based on the user input
 //
@@ -15,8 +15,8 @@ class indexFolder {
     }
 
     async initialize() {
-        // traverse current folder and read all .hbs files
-        const files = await glob('**/*.hbs', { cwd: this.currentFolder, nodir:true, absolute:true });
+        // traverse current folder and read all .md (with hbs) files
+        const files = await glob('**/*.md', { cwd: this.currentFolder, nodir:true, absolute:true });
         for (const file of files) {
             // read 'file' contents
             const content = await fs.readFile(file, 'utf-8');

actions/index.js

@@ -1,6 +1,39 @@
 ```description
 Generates a README file for a project.
 ```
+
+```js:pre
+// what kind of files should I read from this project source to generate the README?
+const files_ = await queryLLM('What are the main files we need from the sourcetree to generate a README of this project?\n'+source_tree, 
+    z.array(z.string()).describe('filenames to read from the given source tree')
+);
+console.log('queryLLM files_',files_.data);
+// read the indicated files and return object overwriting default files (use readFiles helper that takes an array of files and returns an array of objects with a field named 'code')
+// add absolute_code_path prefix to the files if it's not contained
+// filter 'files' to only include the files that are in the 'files_' array
+let filtered = [];
+files = files.map((item)=>{
+    files_.data.some((file)=>{
+        if (item.path.includes(file)){
+            // also truncate the files to 1000 characters
+            item.code = item.code.substring(0, 1000);
+            filtered.push(item);
+            return true;
+        }
+    });
+});
+console.log('filtered', filtered);
+console.log('files_', files_);
+return {
+    files: filtered
+}
+```
+
+```js:pre
+console.log('SECOND JS BLOCK');
+console.log('files2', files);
+```
+
 Project Path: {{ absolute_code_path }}
 
 I'd like you to generate a high-quality README file for this project, suitable for hosting on GitHub. Analyze the codebase to understand the purpose, functionality, and structure of the project. 
@@ -36,7 +69,7 @@ Write the content in Markdown format. Use your analysis of the code to generate
 
 Feel free to infer reasonable details if needed, but try to stick to what can be determined from the codebase itself. Let me know if you have any other questions as you're writing!
 
-```schema
+```json:schema
 {
     "readme": "content of the README file"
 }

actions/write-readme.hbs actions/write-readme.md

@@ -25,6 +25,7 @@ const argv = yargs(hideBin(process.argv))
 const code2prompt = require('code2prompt');
 const safeEval = require('safe-eval');
 const path = require('path');
+const fs = require('fs').promises;
 const currentWorkingDirectory = process.cwd();
 const actionsDirectory = path.join(__dirname, 'actions');
 require('dotenv').config();
@@ -38,7 +39,7 @@ const { z } = require('zod');
     // 0) determine if the input is an action or a question, and the user input language
     const general = new code2prompt({
         path: currentWorkingDirectory,
-        template: path.join(actionsDirectory,'default.hbs'),
+        template: path.join(actionsDirectory,'default.md'),
         extensions: ["js"],
         ignore: ["**/node_modules/**"],
         OPENAI_KEY: process.env.OPENAI_KEY
@@ -55,6 +56,7 @@ const { z } = require('zod');
     if (action_or_question.data.is_action) {
         const user_action = new actionsIndex(argv.input);
         const prompt = await user_action.getPrompt();
+        // declare methods for js code blocks
         let additional_context = { 
             queryLLM:async(question,schema)=>{
                 return await general.queryLLM(question,schema); 
@@ -72,28 +74,48 @@ const { z } = require('zod');
             path: currentWorkingDirectory,
             template: action.data.file,
             extensions: [],
-            ignore: ["**/node_modules/**","**/*.png","**/*.jpg","**/*.gif"],
+            ignore: ["**/node_modules/**","**/*.png","**/*.jpg","**/*.gif","**/package-lock.json","**/.env","**/.gitignore","**/LICENSE"],
             OPENAI_KEY: process.env.OPENAI_KEY
         });
         // get the code blocks
         const code_helper = new (require('./helpers/codeBlocks'));
         const context_prompt = await actioncode.generateContextPrompt(null,true);
+        //console.log('context_prompt',context_prompt);
+        additional_context = {...additional_context,...{
+                absolute_code_path: context_prompt.context.absolutePath,
+                source_tree: context_prompt.context.sourceTree,
+                files: context_prompt.context.filesArray,
+            }
+        };
         const code_blocks = await actioncode.getCodeBlocks();
-        // check if we have 'pre:' code blocks (must run before the template)
+        // check if we have ':pre' code blocks (must run before the template)
         //console.log('code_blocks for choosen template',code_blocks);
         for (const block of code_blocks) {
-            // if block.lang contains 'pre:'
-            if (block.lang.startsWith('pre:js')) {
-                const code_executed = await code_helper.executeNode(additional_context,block.code);
-                // if code_executed is an object
-                if (typeof code_executed === 'object') {
-                    console.log('adding context from pre:js code block',code_executed);
-                    additional_context = {...additional_context,...code_executed};
+            // if block.lang ends with ':pre'
+            if (block.lang.endsWith(':pre')) {
+                // if block.lang contains 'js'
+                if (block.lang.includes('js')) {
+                    const code_executed = await code_helper.executeNode(additional_context,block.code);
+                    // if code_executed is an object
+                    if (typeof code_executed === 'object') {
+                        console.log('adding context from pre:js code block',code_executed);
+                        additional_context = {...additional_context,...code_executed};
+                    }
                 }
             }
         }
         // query the template
-        // check if we have none 'pre:' code blocks (must run after the template)
+        const template_res = await actioncode.request(argv.input, null, {
+            custom_variables: {
+                ...additional_context
+            }
+        });
+        console.log('template_res',template_res);
+        // check if we have none ':pre' code blocks (must run after the template)
+        // add results from template_res.data obj schema to additional_context object
+        additional_context = {...additional_context, ...{
+            schema:template_res.data
+        }};
     }
     // 2) if the input is a question, run the question to the model with the 'default-template' and return the response
 

index.js

@@ -23,7 +23,7 @@
   "dependencies": {
     "@concepto/console": "^1.2.68",
     "code-blocks": "^1.1.0",
-    "code2prompt": "^1.0.6",
+    "code2prompt": "^1.0.71",
     "dotenv": "^16.4.5",
     "glob": "^10.3.12",
     "prompts": "^2.4.2",