fscr 6.2.6 → 7.3.0

package/dist/lib/git/validateNotDev.js

@@ -5,67 +5,78 @@ import { boxInform } from "../utils/helpers.js";
 import git from "git-state";
 import simple from "simple-git";
 const pathToCwd = process.cwd();
+
 const newBranch = async name => {
-  // const last = await new Promise(rzz => {
-  //     git.isGit(pathToCwd, function(exists) {
-  //         if (!exists) return;
+    // const last = await new Promise(rzz => {
+    //     git.isGit(pathToCwd, function(exists) {
+    //         if (!exists) return;
 
-  //
-  //         git.commit(pathToCwd, function(err, result) {
-  //             if (err) throw err;
-  //             rzz(result);
-  //         });
-  //     });
-  // });
+    //
+    //         git.commit(pathToCwd, function(err, result) {
+    //             if (err) throw err;
+    //             rzz(result);
+    //         });
+    //     });
+    // });
 
-  try {
-    // logInfo(command);
-    childProcess.execSync(`git -c core.quotepath=false -c log.showSignature=false checkout -b ${name}`, {
-      stdio: "inherit",
-      env: Object.assign({}, process.env, {
-        FORCE_COLOR: true,
-        PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
-      })
-    });
-  } catch (e) {}
+    try {
+        // logInfo(command);
+       childProcess.execSync(
+            `git -c core.quotepath=false -c log.showSignature=false checkout -b ${name}`,
+            {
+                stdio: "inherit",
+                env: Object.assign({}, process.env, {
+                    FORCE_COLOR: true,
+                    PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
+                })
+            }
+        );
+    } catch (e) {}
 
-  // await simple().checkoutLocalBranch(name);
-  // await simple().checkoutBranch(name, "origin");
-  boxInform(chalk.green(`New branch ${name} created`, "", 5));
+    // await simple().checkoutLocalBranch(name);
+    // await simple().checkoutBranch(name, "origin");
+    boxInform(chalk.green(`New branch ${name} created`, "", 5));
 };
+
 async function pub() {
-  return new Promise(resolve => {
-    inquirer.prompt([{
-      type: "input",
-      message: chalk.bold.hex("#38be18")(`Name new feature branch (or type cancel):`),
-      name: "branchname"
-    }]).then(async ({
-      branchname
-    }) => {
-      if (branchname !== "Development") await newBranch(branchname);
-      resolve();
+    return new Promise(resolve => {
+        inquirer
+            .prompt([
+                {
+                    type: "input",
+                    message: chalk.bold.hex("#38be18")(`Name new feature branch (or type cancel):`),
+                    name: "branchname"
+                }
+            ])
+            .then(async ({ branchname }) => {
+                if (branchname !== "Development") await newBranch(branchname);
+                resolve();
+            });
     });
-  });
 }
+
 const validateNotInDev = async () => {
-  await new Promise(async resolve => {
-    const {
-      default: git
-    } = await import("simple-git/promise");
-    let statusSummary = await git(__dirname).status();
-    if (statusSummary.current === "Development") {
-      console.clear();
-      console.log(boxen(chalk.bold.underline.red("DO NO MAKE CHANGES IN DEV!"), {
-        padding: 2
-      }));
-      await new Promise(resolve1 => setTimeout(() => {
-        resolve1();
-      }, 1000));
-      await pub();
-      resolve();
-    } else {
-      resolve();
-    }
-  });
+    await new Promise(async resolve => {
+        const { default: git } = await import("simple-git/promise");
+
+        let statusSummary = await git(__dirname).status();
+        if (statusSummary.current === "Development") {
+            console.clear();
+            console.log(
+                boxen(chalk.bold.underline.red("DO NO MAKE CHANGES IN DEV!"), {
+                    padding: 2
+                })
+            );
+            await new Promise(resolve1 =>
+                setTimeout(() => {
+                    resolve1();
+                }, 1000)
+            );
+            await pub();
+            resolve();
+        } else {
+            resolve();
+        }
+    });
 };
-export default validateNotInDev;
+export default validateNotInDev;

package/dist/lib/optionList.js

@@ -1,61 +1,73 @@
 const separator = "   ~   ";
 import chalk from "chalk";
 import enquirerPkg from "enquirer";
-const {
-  prompt
-} = enquirerPkg;
-const optionList = async () => {
-  let choiceCategories = [{
-    name: "start",
-    message: "Choose category then task to run"
-  }, {
-    name: "list",
-    message: "Select any task with text autocompletion"
-  }, {
-    name: "scripts",
-    message: "Choose a script from package.json"
-  }, {
-    name: "upgrade",
-    message: "Upgrade all your packages except ones specified by 'ignore-upgrade':[]"
-  }, {
-    name: "remote",
-    message: "Get remote configuration with your fc email"
-  }, {
-    name: "bump",
-    message: "Bump package.json and beautify it!"
-  }, {
-    name: "encryption",
-    message: "Encrypt/Decrypt secret files"
-  }, {
-    name: "clear",
-    message: "Clear recent task history"
-  }, {
-    name: "generate",
-    message: "Generate a sample fscripts.md file from the package.json"
-  }, {
-    name: "toc",
-    message: "Generate updated Table of Contents on top of the fscripts.md file"
-  }, {
-    name: "--help",
-    message: "See full help documentation"
-  }];
-  try {
-    let {
-      answer
-    } = await prompt({
-      type: "select",
-      name: `answer`,
-      choiceMessage: e => {
-        // return JSON.stringify(e)
-        // return e.message;
-        return `${chalk.bold.underline(e.name)}${chalk.reset(": \n  ")}${chalk.gray.italic(e.message)}`;
-      },
-      message: `${chalk.cyan.bold.underline("What category do you want to run?")}`,
-      choices: choiceCategories
-    });
-    return answer;
-  } catch (e) {
-    return false;
-  }
+const { prompt } = enquirerPkg;
+const optionList = async (extraChoices = []) => {
+    let choiceCategories = [
+        {
+            name: "start",
+            message: "Choose category then task to run"
+        },
+        {
+            name: "list",
+            message: "Select any task with text autocompletion"
+        },
+        {
+            name: "scripts",
+            message: "Choose a script from package.json"
+        },
+        {
+            name: "upgrade",
+            message: "Upgrade all your packages except ones specified by 'ignore-upgrade':[]"
+        },
+        {
+            name: "remote",
+            message: "Get remote configuration with your fc email"
+        },
+        {
+            name: "bump",
+            message: "Bump package.json and beautify it!"
+        },
+        {
+            name: "encryption",
+            message: "Encrypt/Decrypt secret files"
+        },
+        {
+            name: "clear",
+            message: "Clear recent task history"
+        },
+        {
+            name: "generate",
+            message: "Generate a sample fscripts.md file from the package.json"
+        },
+        {
+            name: "toc",
+            message: "Generate updated Table of Contents on top of the fscripts.md file"
+        },
+        {
+            name: "--help",
+            message: "See full help documentation"
+        },
+        ...extraChoices
+    ];
+    try {
+        let { answer } = await prompt({
+            type: "select",
+            name: `answer`,
+            choiceMessage: (e) => {
+                // return JSON.stringify(e)
+                // return e.message;
+                return `${chalk.bold.underline(e.name)}${chalk.reset(": \n  ")}${chalk.gray.italic(
+                    e.message
+                )}`;
+            },
+            message: `${chalk.cyan.bold.underline("What category do you want to run?")}`,
+            choices: choiceCategories
+        });
+        return answer;
+    } catch (e) {
+        return false;
+    }
 };
-export default optionList;
+
+export default optionList;

package/dist/lib/parsers/parseScriptsMd.cached.js

@@ -0,0 +1,208 @@
+/**
+ * Cached version of parseScriptsMd
+ * Adds smart caching with TTL and file watching
+ */
+
+import path from "path";
+import fs from "fs";
+import { getCache } from "../cache/index.js";
+import FileWatcher from "../cache/file-watcher.js";
+import { marked } from "marked";
+
+// Initialize cache and file watcher
+let cache = null;
+let fileWatcher = null;
+
+/**
+ * Get or create cache instance
+ */
+function getOrCreateCache() {
+    if (!cache) {
+        cache = getCache({
+            defaultTTL: 300000, // 5 minutes
+            maxSize: 100,
+            enableStats: true
+        });
+    }
+    return cache;
+}
+
+/**
+ * Get or create file watcher
+ */
+function getOrCreateWatcher() {
+    if (!fileWatcher) {
+        const cacheInstance = getOrCreateCache();
+        fileWatcher = new FileWatcher(cacheInstance, {
+            debounceMs: 100
+        });
+    }
+    return fileWatcher;
+}
+
+/**
+ * Parse markdown content to script structure
+ * (Same logic as original parseScriptFile)
+ */
+const parse = function(mdContent) {
+    let js = marked.lexer(mdContent);
+    js = js.filter(e => e.type !== "space");
+
+    let listMe = js.slice();
+    let tempItem = {};
+    let currentCategory = "";
+    let currentTask = "";
+    let taskOrder = 0;
+
+    listMe.forEach((item, indx) => {
+        if (item.type === "heading" && item.depth === 1) {
+            taskOrder = 0;
+            currentCategory = item.text;
+            tempItem[currentCategory] = { name: item.text, tasks: {}, description: "" };
+            let descriptor = js[indx + 1];
+            if (descriptor && descriptor.type === "paragraph") {
+                tempItem[currentCategory].description = descriptor.text;
+            }
+        } else if (item.type === "heading" && item.depth === 2) {
+            currentTask = item.text;
+            tempItem[currentCategory].tasks[currentTask] = {
+                script: "",
+                name: currentTask,
+                description: "",
+                order: taskOrder
+            };
+            taskOrder++;
+            let descriptor = js[indx + 1];
+            let code = js[indx + 2];
+            if (descriptor && descriptor.type === "paragraph" && code && code.type === "code") {
+                tempItem[currentCategory].tasks[currentTask].description = descriptor.text;
+                tempItem[currentCategory].tasks[currentTask].lang = code.lang;
+                tempItem[currentCategory].tasks[currentTask].script = code.text;
+            } else if (descriptor && descriptor.type === "code") {
+                tempItem[currentCategory].tasks[currentTask].lang = descriptor.lang;
+                tempItem[currentCategory].tasks[currentTask].script = descriptor.text;
+            }
+        }
+    });
+
+    let allTasks = [];
+    let categories = Object.keys(tempItem).map(catName => {
+        let ts = tempItem[catName].tasks;
+        let tasksArr = Object.keys(ts).map(tn => ts[tn]);
+        allTasks = [...allTasks, ...tasksArr];
+        return { name: catName, ...tempItem[catName] };
+    });
+
+    return { categories, allTasks };
+};
+
+/**
+ * Parse script file with caching
+ * @param {Object} options - Options
+ * @param {boolean} [options.useCache=true] - Whether to use cache
+ * @param {boolean} [options.watchFile=true] - Whether to watch file for changes
+ * @returns {Promise<Object|boolean>} Parsed scripts or false
+ */
+const parseScriptFile = async (options = {}) => {
+    const useCache = options.useCache !== false;
+    const watchFile = options.watchFile !== false;
+
+    const fscriptsPath = path.resolve(process.cwd(), "fscripts.md");
+
+    // Check if file exists
+    if (!fs.existsSync(fscriptsPath)) {
+        return false;
+    }
+
+    // Try cache first
+    if (useCache) {
+        const cacheInstance = getOrCreateCache();
+        const cacheKey = cacheInstance.generateFileKey(fscriptsPath);
+        const cached = cacheInstance.get(cacheKey);
+
+        if (cached) {
+            // Cache hit - return cached data
+            return cached;
+        }
+
+        // Cache miss - parse file
+        const data = fs.readFileSync(fscriptsPath, "utf-8");
+        if (data === null || data === undefined) {
+            return false;
+        }
+
+        // Handle empty file - return empty structure
+        if (data === "") {
+            const emptyResult = { categories: [], allTasks: [] };
+            cacheInstance.set(cacheKey, emptyResult, { filePath: fscriptsPath });
+            return emptyResult;
+        }
+
+        let newContent = data.split("<!-- end toc -->");
+        newContent = newContent[newContent.length === 2 ? 1 : 0];
+        const parsed = parse(newContent);
+
+        // Store in cache
+        cacheInstance.set(cacheKey, parsed, { filePath: fscriptsPath });
+
+        // Watch file for changes if enabled
+        if (watchFile) {
+            const watcher = getOrCreateWatcher();
+            if (!watcher.isWatching(fscriptsPath)) {
+                watcher.watch(fscriptsPath);
+            }
+        }
+
+        return parsed;
+    } else {
+        // No cache - parse directly
+        const data = fs.readFileSync(fscriptsPath, "utf-8");
+        if (data === null || data === undefined) {
+            return false;
+        }
+
+        // Handle empty file - return empty structure
+        if (data === "") {
+            return { categories: [], allTasks: [] };
+        }
+
+        let newContent = data.split("<!-- end toc -->");
+        newContent = newContent[newContent.length === 2 ? 1 : 0];
+        return parse(newContent);
+    }
+};
+
+/**
+ * Clear cache manually
+ */
+export function clearCache() {
+    if (cache) {
+        cache.clear();
+    }
+}
+
+/**
+ * Get cache statistics
+ */
+export function getCacheStats() {
+    if (cache) {
+        return cache.getStats();
+    }
+    return null;
+}
+
+/**
+ * Destroy cache and watcher (cleanup)
+ */
+export function destroyCache() {
+    if (fileWatcher) {
+        fileWatcher.destroy();
+        fileWatcher = null;
+    }
+    if (cache) {
+        cache.destroy();
+        cache = null;
+    }
+}
+
+export default parseScriptFile;

package/dist/lib/parsers/parseScriptsMd.js

@@ -1,90 +1,99 @@
 import path from "path";
 import chalk from "chalk";
 import fs from "fs";
-const flattenObject = (obj, prefix = "") => Object.keys(obj).reduce((acc, k) => {
-  const pre = prefix.length ? prefix + "." : "";
-  if (typeof obj[k] === "object") Object.assign(acc, flattenObject(obj[k], pre + k));else acc[pre + k] = obj[k];
-  return acc;
-}, {});
+const flattenObject = (obj, prefix = "") =>
+    Object.keys(obj).reduce((acc, k) => {
+        const pre = prefix.length ? prefix + "." : "";
+        if (typeof obj[k] === "object") Object.assign(acc, flattenObject(obj[k], pre + k));
+        else acc[pre + k] = obj[k];
+        return acc;
+    }, {});
+
 import { marked } from "marked";
-let parse = function (mdContent) {
-  let js = marked.lexer(mdContent);
-  js = js.filter(e => e.type !== "space");
 
-  // let firstHeading = js.findIndex(e => e.type === "heading" && e.depth === 1); //?
-  let listMe = js.slice();
-  let tempItem = {};
-  let currentCategory = "";
-  let currentTask = "";
-  let taskOrder = 0;
-  listMe.forEach((item, indx) => {
-    if (item.type === "heading" && item.depth === 1) {
-      taskOrder = 0;
-      currentCategory = item.text;
-      tempItem[currentCategory] = {
-        name: item.text,
-        tasks: {},
-        description: ""
-      };
-      let descriptor = js[indx + 1];
-      if (descriptor.type === "paragraph") {
-        tempItem[currentCategory].description = descriptor.text;
-      }
-    } else if (item.type === "heading" && item.depth === 2) {
-      currentTask = item.text;
-      tempItem[currentCategory].tasks[currentTask] = {
-        script: "",
-        name: currentTask,
-        description: "",
-        order: taskOrder
-      };
-      taskOrder++;
-      let descriptor = js[indx + 1];
-      let code = js[indx + 2];
-      if (descriptor.type === "paragraph" && code.type === "code") {
-        tempItem[currentCategory].tasks[currentTask].description = descriptor.text;
-        tempItem[currentCategory].tasks[currentTask].lang = code.lang;
-        tempItem[currentCategory].tasks[currentTask].script = code.text;
-      } else if (descriptor.type === "code") {
-        // if (descriptor.lang === "javascript") {
-        //     console.info("Console --- ", descriptor);
-        // }
-        tempItem[currentCategory].tasks[currentTask].lang = descriptor.lang;
-        tempItem[currentCategory].tasks[currentTask].script = descriptor.text;
-      }
-    }
-  });
-  let allTasks = [];
-  let categories = Object.keys(tempItem).map(catName => {
-    let ts = tempItem[catName].tasks;
-    let tasksArr = Object.keys(ts).map(tn => ts[tn]);
-    allTasks = [...allTasks, ...tasksArr];
-    return {
-      name: catName,
-      ...tempItem[catName]
-    };
-  });
-  return {
-    categories,
-    allTasks
-  };
+let parse = function(mdContent) {
+    let js = marked.lexer(mdContent);
+    js = js.filter(e => e.type !== "space");
+
+    // let firstHeading = js.findIndex(e => e.type === "heading" && e.depth === 1); //?
+    let listMe = js.slice();
+    let tempItem = {};
+    let currentCategory = "";
+    let currentTask = "";
+    let taskOrder = 0;
+    listMe.forEach((item, indx) => {
+        if (item.type === "heading" && item.depth === 1) {
+            taskOrder = 0;
+            currentCategory = item.text;
+            tempItem[currentCategory] = { name: item.text, tasks: {}, description: "" };
+            let descriptor = js[indx + 1];
+            if (descriptor.type === "paragraph") {
+                tempItem[currentCategory].description = descriptor.text;
+            }
+        } else if (item.type === "heading" && item.depth === 2) {
+            currentTask = item.text;
+            tempItem[currentCategory].tasks[currentTask] = {
+                script: "",
+                name: currentTask,
+                description: "",
+                order: taskOrder
+            };
+            taskOrder++;
+            let descriptor = js[indx + 1];
+            let code = js[indx + 2];
+            if (descriptor.type === "paragraph" && code.type === "code") {
+                tempItem[currentCategory].tasks[currentTask].description = descriptor.text;
+                tempItem[currentCategory].tasks[currentTask].lang = code.lang;
+                tempItem[currentCategory].tasks[currentTask].script = code.text;
+            } else if (descriptor.type === "code") {
+                // if (descriptor.lang === "javascript") {
+                //     console.info("Console --- ", descriptor);
+                // }
+                tempItem[currentCategory].tasks[currentTask].lang = descriptor.lang;
+                tempItem[currentCategory].tasks[currentTask].script = descriptor.text;
+            }
+        }
+    });
+    let allTasks = [];
+    let categories = Object.keys(tempItem).map(catName => {
+        let ts = tempItem[catName].tasks;
+        let tasksArr = Object.keys(ts).map(tn => ts[tn]);
+        allTasks = [...allTasks, ...tasksArr];
+        return { name: catName, ...tempItem[catName] };
+    });
+
+    return { categories, allTasks };
 };
-const parseScriptFile = async () => {
-  const data = await fs.readFileSync(path.resolve(process.cwd(), "fscripts.md"), "utf-8");
-  if (!data) {
-    //         console.warn(
-    //             `${chalk.bold.red("You're missing the fscripts.md file!")}
-    // ${chalk.green("Please run 'fsr generate' to get started!")}`
-    //         );
-    //
-    //         process.exit(0);
-    //         return null;
-    return false;
-  } else {
+const parseScriptFile = async (options = {}) => {
+    // Use caching by default (can be disabled with { useCache: false })
+    const useCache = options.useCache !== false;
+
+    if (useCache) {
+        // Import cached version dynamically
+        try {
+            const { default: cachedParse } = await import('./parseScriptsMd.cached.js');
+            return cachedParse(options);
+        } catch (error) {
+            // Fallback to non-cached version if import fails
+            console.warn('Cache module not available, using direct parsing');
+        }
+    }
+
+    // Non-cached version (original logic)
+    const data = await fs.readFileSync(path.resolve(process.cwd(), "fscripts.md"), "utf-8");
+    if (data === null || data === undefined) {
+        return false;
+    }
+
+    // Handle empty file - return empty structure
+    if (data === "") {
+        return { categories: [], allTasks: [] };
+    }
+
     // console.warn(`${chalk.bold.green("Located fscripts.md file!")}`);
     let newContent = data.split("<!-- end toc -->");
     newContent = newContent[newContent.length === 2 ? 1 : 0];
     return parse(newContent);
-  }
 };
-export default parseScriptFile;
+
+export default parseScriptFile;

package/dist/lib/parsers/parseScriptsPackage.js

@@ -3,7 +3,8 @@ import chalk from "chalk";
 const projectPath = path.join(process.cwd(), "./package.json");
 import { readJson } from "../utils/helpers.js";
 const parseScriptFile = async () => {
-  const packageFile = await readJson(projectPath);
-  return packageFile.scripts;
+    const packageFile = await readJson(projectPath);
+    return packageFile.scripts;
 };
-export default parseScriptFile;
+
+export default parseScriptFile;