@agent-smith/cli 0.0.105 → 0.0.107

package/dist/cmd/clicmds/base.js

@@ -3,7 +3,7 @@ import { listBackends, setBackend } from "../../state/backends.js";
 import { parseCommandArgs } from "../lib/options_parsers.js";
 import { processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd } from "./cmds.js";
 import { updateConfCmd } from "./updateconf.js";
-import { inferenceOptions } from "../options.js";
+import { displayOptions, inferenceOptions } from "../options.js";
 function initBaseCommands(program) {
     program.command("exit")
         .description("exit the cli")
@@ -34,11 +34,13 @@ function initBaseCommands(program) {
         .action(async (...args) => {
         await listBackends();
     });
-    program.command("update")
+    const updateCmd = program.command("update")
         .description("update the available features: run this after adding a new feature")
         .action(async (...args) => {
-        await updateFeaturesCmd();
+        const ca = parseCommandArgs(args);
+        await updateFeaturesCmd(ca.options);
     });
+    displayOptions.forEach(o => updateCmd.addOption(o));
     program.command("conf <path>")
         .description("process config file")
         .action(async (...args) => {

package/dist/cmd/clicmds/cmds.d.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { FeatureSpec } from '../../interfaces.js';
 declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>): Promise<Array<Command>>;
 declare function resetDbCmd(): Promise<any>;
-declare function updateFeaturesCmd(): Promise<any>;
+declare function updateFeaturesCmd(options: Record<string, any>): Promise<any>;
 declare function processTasksCmd(args: Array<string>, options: Record<string, any>): Promise<void>;
 declare function processTaskCmd(args: Array<string>, options: Record<string, any>): Promise<any>;
 export { initUserCmds, processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd };

package/dist/cmd/clicmds/cmds.js

@@ -1,10 +1,9 @@
 import colors from "ansi-colors";
 import path from "path";
 import YAML from 'yaml';
-import { cacheFilePath, dbPath } from "../../conf.js";
+import { dbPath } from "../../conf.js";
 import { readFeaturePaths, readFeaturesType, readTaskSetting } from "../../db/read.js";
 import { cleanupFeaturePaths, deleteTaskSetting, updateAliases, updateFeatures, upsertTaskSettings } from "../../db/write.js";
-import { isCacheReady, cmds } from "../../state/auto/usercmds.js";
 import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
 import { readPluginsPaths } from "../../state/plugins.js";
 import { runMode } from "../../state/state.js";
@@ -12,21 +11,17 @@ import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from '../.
 import { deleteFileIfExists } from "../sys/delete_file.js";
 import { readCmd } from "../sys/read_cmds.js";
 import { readTask } from "../sys/read_task.js";
-import { updateUserCmdsCache } from './cache.js';
 async function initUserCmds(cmdFeats) {
     const features = Object.values(cmdFeats);
-    let endCmds = cmds;
-    if (!isCacheReady) {
-        updateUserCmdsCache(cacheFilePath, features);
-        const usrCmds = [];
-        for (const feat of features) {
-            const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
-            const c = await readCmd(feat.name, cmdPath);
+    const usrCmds = [];
+    for (const feat of features) {
+        const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+        const c = await readCmd(feat.name, cmdPath);
+        if (c) {
             usrCmds.push(c);
         }
-        endCmds = usrCmds;
     }
-    return endCmds;
+    return usrCmds;
 }
 async function resetDbCmd() {
     if (runMode.value == "cli") {
@@ -36,18 +31,17 @@ async function resetDbCmd() {
     deleteFileIfExists(dbPath);
     console.log("Config database reset ok. Run the conf command to recreate it");
 }
-async function updateFeaturesCmd() {
+async function updateFeaturesCmd(options) {
     const fp = readFeaturePaths();
     const pp = await readPluginsPaths();
     const paths = [...fp, ...pp];
-    const feats = readFeaturesDirs(paths);
+    const feats = readFeaturesDirs(paths, options?.debug ?? false);
     updateFeatures(feats);
     updateAliases(feats);
     const deleted = cleanupFeaturePaths(paths);
     for (const el of deleted) {
         console.log("- [feature path]", el);
     }
-    updateUserCmdsCache(cacheFilePath, feats.cmd);
 }
 async function processTasksCmd(args, options) {
     if (options?.conf) {

package/dist/cmd/clicmds/updateconf.js

@@ -1,11 +1,10 @@
-import { cacheFilePath, processConfPath } from "../../conf.js";
+import { processConfPath } from "../../conf.js";
 import { initDb } from "../../db/db.js";
 import { readFilePath } from "../../db/read.js";
 import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, updatePromptfilePath, upsertFilePath } from "../../db/write.js";
 import { readFeaturesDirs } from "../../state/features.js";
 import { dataDirPath, promptfilePath } from "../../state/state.js";
 import { runtimeDataError, runtimeInfo } from '../lib/user_msgs.js';
-import { updateUserCmdsCache } from "./cache.js";
 async function updateConfCmd(args) {
     initDb(false, true);
     const { found, path } = readFilePath("conf");
@@ -34,13 +33,12 @@ async function updateConfCmd(args) {
         updateDataDirPath(dd);
         dataDirPath.value = dd;
     }
-    const feats = readFeaturesDirs(paths);
+    const feats = readFeaturesDirs(paths, true);
     updateFeatures(feats);
     updateAliases(feats);
     const deleted = cleanupFeaturePaths(paths);
     for (const el of deleted) {
         console.log("- [feature path]", el);
     }
-    updateUserCmdsCache(cacheFilePath, feats.cmd);
 }
 export { updateConfCmd, };

package/dist/cmd/lib/actions/cmd.js

@@ -9,8 +9,15 @@ import { readClipboard } from "../../sys/clipboard.js";
 import { processOutput, readPromptFile } from "../utils.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { pathToFileURL } from 'url';
+import { getInputFromOptions } from '../tasks/utils.js';
 async function executeAction(name, payload, options, quiet = false) {
     let run;
+    const inputData = await getInputFromOptions(options);
+    if (inputData) {
+        if (Array.isArray(payload)) {
+            payload.push(inputData);
+        }
+    }
     const { found, path, ext } = getFeatureSpec(name, "action");
     if (!found) {
         throw new Error(`Action ${name} not found at ${path}`);
@@ -117,6 +124,7 @@ function pythonAction(path) {
                 final = JSON.parse(txt);
             }
             catch (e) {
+                console.warn("Can not parse json from python action", path, e);
             }
         }
         return final;

package/dist/cmd/lib/adaptaters/cmd.js

@@ -1,11 +1,18 @@
 import { getFeatureSpec } from "../../../state/features.js";
 import { createJsAction } from "../actions/read.js";
 import { pathToFileURL } from 'url';
+import { getInputFromOptions } from "../tasks/utils.js";
 async function executeAdaptater(name, params, options) {
     const { found, path } = getFeatureSpec(name, "adaptater");
     if (!found) {
         throw new Error(`adaptater ${name} not found`);
     }
+    const inputData = await getInputFromOptions(options);
+    if (inputData) {
+        if (Array.isArray(params)) {
+            params.push(inputData);
+        }
+    }
     let run;
     const url = pathToFileURL(path).href;
     const jsa = await import(url);

package/dist/cmd/lib/tasks/cmd.js

@@ -1,6 +1,6 @@
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
 import { default as color, default as colors } from "ansi-colors";
-import { PromptTemplate } from "modprompt";
+import { PromptTemplate, templates } from "modprompt";
 import ora from 'ora';
 import { usePerfTimer } from "../../../main.js";
 import { backend, backends, listBackends } from "../../../state/backends.js";
@@ -92,7 +92,12 @@ async function executeTask(name, payload, options) {
     let hasThink = false;
     let tpl = null;
     if (useTemplates) {
-        tpl = new PromptTemplate(model.template ?? "none");
+        try {
+            tpl = new PromptTemplate(model.template ?? "none");
+        }
+        catch (e) {
+            throw new Error(`Can not load template ${model.template}\nAvailable templates: ${Object.keys(templates)}\n`);
+        }
         hasThink = tpl.tags?.think ? true : false;
     }
     if (options?.debug) {
@@ -110,7 +115,6 @@ async function executeTask(name, payload, options) {
         else {
             process.stdout.write(t);
         }
-        ++emittedTokens;
     };
     let hasTools = false;
     if (task.def?.tools) {
@@ -176,7 +180,11 @@ async function executeTask(name, payload, options) {
                     return;
                 }
             }
-            printToken(t);
+            if (!options?.quiet) {
+                if (!options?.isToolCall || (options?.debug || options.verbose)) {
+                    printToken(t);
+                }
+            }
         }
         ++emittedTokens;
     };
@@ -224,7 +232,11 @@ async function executeTask(name, payload, options) {
             return;
         }
         else if (errMsg.includes("404 Not Found")) {
-            runtimeError("The server answered with a 404 Not Found error. That usually mean that the model you are requesting does not exist on the server.");
+            runtimeError("The server answered with a 404 Not Found error. That might mean that the model you are requesting does not exist on the server.");
+            return;
+        }
+        else if (errMsg.includes("400 Bad Request")) {
+            runtimeError("The server answered with a 400 Bad Request error. That might mean that the model you are requesting does not exist on the server or a parameter is missing in your request.");
             return;
         }
         else if (errMsg.includes("fetch failed")) {
@@ -241,7 +253,7 @@ async function executeTask(name, payload, options) {
         }
     }
     if (!isChatMode.value || options?.isToolCall) {
-        if (options?.debug) {
+        if (options?.debug && mcpServers.length > 0) {
             console.log("Closing", mcpServers.length, "mcp server(s)");
         }
         mcpServers.forEach((s) => {

package/dist/cmd/lib/tasks/read.js

@@ -123,13 +123,16 @@ async function readTask(name, payload, options, agent) {
                             options.isToolCall = true;
                             options.isAgent = true;
                             const agres = await executeTask(toolName, params, options);
+                            options.isAgent = false;
                             options.isToolCall = false;
                             if (agres?.answer?.text) {
                                 return agres.answer.text;
                             }
                             return agres;
                         case "workflow":
+                            options.isToolCall = true;
                             const wres = await executeWorkflow(toolName, params, options);
+                            options.isToolCall = false;
                             return wres;
                         default:
                             throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);

package/dist/cmd/lib/tasks/utils.d.ts

@@ -3,5 +3,6 @@ declare function openTaskSpec(name: string, isAgent?: boolean): {
     taskFileSpec: LmTaskFileSpec;
     taskPath: string;
 };
+declare function getInputFromOptions(options: Record<string, any>): Promise<string | null>;
 declare function getTaskPrompt(name: string, args: Array<string>, options: Record<string, any>): Promise<string>;
-export { getTaskPrompt, openTaskSpec };
+export { getTaskPrompt, getInputFromOptions, openTaskSpec, };

package/dist/cmd/lib/tasks/utils.js

@@ -18,23 +18,31 @@ function openTaskSpec(name, isAgent = false) {
     taskFileSpec.name = name;
     return { taskFileSpec: taskFileSpec, taskPath: path };
 }
-async function getTaskPrompt(name, args, options) {
-    let pr;
+async function getInputFromOptions(options) {
+    let out = null;
     if (options?.clipboardInput === true) {
-        pr = await readClipboard();
+        out = await readClipboard();
+        options.clipboardInput = false;
     }
     else if (options?.inputFile === true) {
-        pr = readPromptFile();
+        out = readPromptFile();
+        options.inputFile = false;
+    }
+    return out;
+}
+async function getTaskPrompt(name, args, options) {
+    const ic = await getInputFromOptions(options);
+    if (ic) {
+        return ic;
+    }
+    let pr;
+    if (args[0] !== undefined) {
+        pr = args[0];
     }
     else {
-        if (args[0] !== undefined) {
-            pr = args[0];
-        }
-        else {
-            runtimeDataError("task", name, "provide a prompt or use input options");
-            throw new Error();
-        }
+        runtimeDataError(options?.isAgent ? "agent" : "task", name, "provide a prompt or use input options");
+        throw new Error();
     }
     return pr;
 }
-export { getTaskPrompt, openTaskSpec };
+export { getTaskPrompt, getInputFromOptions, openTaskSpec, };

package/dist/cmd/lib/workflows/cmd.d.ts

@@ -1,3 +1,3 @@
 declare function executeWorkflow(wname: string, args: any, options?: Record<string, any>): Promise<any>;
 declare function executeWorkflowCmd(name: string, wargs: Array<any>): Promise<any>;
-export { executeWorkflow, executeWorkflowCmd, };
+export { executeWorkflow, executeWorkflowCmd };

package/dist/cmd/lib/workflows/cmd.js

@@ -1,13 +1,13 @@
+import colors from "ansi-colors";
+import { pathToFileURL } from "node:url";
+import { getFeatureSpec } from "../../../state/features.js";
 import { executeAction } from "../actions/cmd.js";
 import { executeAdaptater } from "../adaptaters/cmd.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { executeTask } from "../tasks/cmd.js";
-import { getTaskPrompt } from "../tasks/utils.js";
-import { readWorkflow } from "./read.js";
-import colors from "ansi-colors";
-import { getFeatureSpec } from "../../../state/features.js";
-import { pathToFileURL } from "node:url";
+import { getInputFromOptions, getTaskPrompt } from "../tasks/utils.js";
 import { runtimeError } from "../user_msgs.js";
+import { readWorkflow } from "./read.js";
 async function executeWorkflow(wname, args, options = {}) {
     const { workflow, found } = await readWorkflow(wname);
     if (!found) {
@@ -39,11 +39,19 @@ async function executeWorkflow(wname, args, options = {}) {
                             if (prevStepType == "task") {
                                 tdata.prompt = taskRes.answer.text;
                             }
+                            else if (prevStepType == "action") {
+                                if (taskRes?.args) {
+                                    if (typeof taskRes.args == "string") {
+                                        tdata.prompt = taskRes.args;
+                                    }
+                                }
+                            }
                         }
                     }
                     if (!tdata?.prompt) {
                         throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
                     }
+                    options.isAgent = false;
                     const tr = await executeTask(step.name, tdata, options);
                     taskRes = { ...tr, ...taskRes };
                 }
@@ -62,6 +70,13 @@ async function executeWorkflow(wname, args, options = {}) {
                             if (prevStepType == "task") {
                                 tdata.prompt = taskRes.answer.text;
                             }
+                            else if (prevStepType == "action") {
+                                if (taskRes?.args) {
+                                    if (typeof taskRes.args == "string") {
+                                        tdata.prompt = taskRes.args;
+                                    }
+                                }
+                            }
                         }
                     }
                     if (!tdata?.prompt) {
@@ -78,17 +93,28 @@ async function executeWorkflow(wname, args, options = {}) {
                 break;
             case "action":
                 try {
-                    const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
+                    let actArgs;
+                    if (i == 0) {
+                        actArgs = taskRes.cmdArgs;
+                        const inputData = await getInputFromOptions(options);
+                        if (inputData) {
+                            actArgs.push(inputData);
+                        }
+                    }
+                    else {
+                        actArgs = taskRes;
+                    }
                     const ares = await executeAction(step.name, actArgs, options, true);
+                    if (i == finalTaskIndex && !options?.isToolCall && !options?.quiet) {
+                        console.log(ares);
+                        break;
+                    }
                     if (typeof ares == "string" || Array.isArray(ares)) {
                         taskRes.args = ares;
                     }
                     else {
                         taskRes = { ...ares, ...taskRes };
                     }
-                    if (i == finalTaskIndex) {
-                        console.log(taskRes);
-                    }
                 }
                 catch (e) {
                     throw new Error(`workflow action ${i + 1}: ${e}`);
@@ -96,17 +122,28 @@ async function executeWorkflow(wname, args, options = {}) {
                 break;
             case "adaptater":
                 try {
-                    const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
+                    let actArgs;
+                    if (i == 0) {
+                        actArgs = taskRes.cmdArgs;
+                        const inputData = await getInputFromOptions(options);
+                        if (inputData) {
+                            actArgs.push(inputData);
+                        }
+                    }
+                    else {
+                        actArgs = taskRes;
+                    }
                     const adres = await executeAdaptater(step.name, actArgs, options);
+                    if (i == finalTaskIndex && !options?.isToolCall && !options?.quiet) {
+                        console.log(adres);
+                        break;
+                    }
                     if (typeof adres == "string" || Array.isArray(adres)) {
                         taskRes.args = adres;
                     }
                     else {
                         taskRes = { ...adres };
                     }
-                    if (i == finalTaskIndex) {
-                        console.log(taskRes);
-                    }
                 }
                 catch (e) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
@@ -124,7 +161,18 @@ async function executeWorkflow(wname, args, options = {}) {
                         runtimeError(`workflow ${wname}: can not import the runCmd function from step ${i} for command ${step.name}: please add a runCmd function export`);
                         return;
                     }
-                    const cres = await jsa.runCmd(args, options);
+                    let cArgs;
+                    if (i == 0) {
+                        cArgs = taskRes.cmdArgs;
+                        const inputData = await getInputFromOptions(options);
+                        if (inputData) {
+                            cArgs.push(inputData);
+                        }
+                    }
+                    else {
+                        cArgs = taskRes;
+                    }
+                    const cres = await jsa.runCmd(cArgs, options);
                     if (typeof cres == "string" || Array.isArray(cres)) {
                         taskRes.args = cres;
                     }
@@ -148,4 +196,4 @@ async function executeWorkflowCmd(name, wargs) {
     const { args, options } = parseCommandArgs(wargs);
     return await executeWorkflow(name, args, options);
 }
-export { executeWorkflow, executeWorkflowCmd, };
+export { executeWorkflow, executeWorkflowCmd };

package/dist/cmd/sys/read_cmds.d.ts

@@ -1,3 +1,3 @@
 import { Command } from "commander";
-declare function readCmd(name: string, cmdPath: string): Promise<Command>;
+declare function readCmd(name: string, cmdPath: string): Promise<Command | null>;
 export { readCmd };

package/dist/cmd/sys/read_cmds.js

@@ -1,12 +1,19 @@
 import { pathToFileURL } from 'url';
+import { runtimeWarning } from "../lib/user_msgs.js";
 async function readCmd(name, cmdPath) {
-    const cmds = new Array();
     const url = pathToFileURL(cmdPath).href;
-    const { cmd } = await import(url);
-    if (!cmd) {
-        throw new Error(`command ${name} not found at ${cmdPath}`);
+    let _cmd = null;
+    try {
+        const mod = await import(url);
+        _cmd = mod.cmd;
     }
-    cmds.push(cmd);
-    return cmd;
+    catch (e) {
+        runtimeWarning(`command ${name} not found at ${cmdPath}, ${e}`);
+        return null;
+    }
+    if (!_cmd) {
+        throw new Error("no cmd");
+    }
+    return _cmd;
 }
 export { readCmd };

package/dist/db/db.js

@@ -16,7 +16,7 @@ function initDb(isVerbose, execSchema) {
         });
     }
     else {
-        db = new DatabaseConstructor(dbPath);
+        db = new DatabaseConstructor(dbPath, { fileMustExist: true });
     }
 }
 export { db, initDb, };

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { argv } from 'process';
 import { query } from "./cli.js";
+import { resetDbCmd } from './cmd/clicmds/cmds.js';
+import { updateConfCmd } from './cmd/clicmds/updateconf.js';
 import { buildCmds, parseCmd } from './cmd/cmds.js';
 import { formatMode, init, inputMode, isChatMode, outputMode, runMode } from './state/state.js';
-import { updateConfCmd } from './cmd/clicmds/updateconf.js';
-import { resetDbCmd } from './cmd/clicmds/cmds.js';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {

package/dist/state/auto/usercmds.js

@@ -1,12 +1,3 @@
-import { cmd as c1 } from "file:///home/ggg/lm/features/dist/cmds/testcmd.js";
-import { cmd as c2 } from "file:///home/ggg/dev/js/agent-smith-plugins/system/fs/dist/cmds/lsdir.js";
-import { cmd as c3 } from "file:///home/ggg/dev/js/agent-smith-plugins/code/git/dist/cmds/commit.js";
-import { cmd as c4 } from "file:///home/ggg/dev/js/agent-smith-plugins/code/git/dist/cmds/commita.js";
-import { cmd as c5 } from "file:///home/ggg/dev/js/agent-smith-plugins/vision/dist/cmds/imgs2base64.js";
-import { cmd as c6 } from "file:///home/ggg/dev/js/snowind-astro/features/cmds/design-component.js";
-import { cmd as c7 } from "file:///home/ggg/dev/js/docdundee/package/features/dist/cmds/tsdoccmd.js";
-
-const cmds = [ c1, c2, c3, c4, c5, c6, c7 ];
-const isCacheReady = true;
-
-export { isCacheReady, cmds }
+const cmds = new Array();
+const isCacheReady = false;
+export { cmds, isCacheReady, };

package/dist/state/features.d.ts

@@ -1,5 +1,5 @@
 import { FeatureExtension, FeatureType, Features } from "../interfaces.js";
-declare function readFeaturesDirs(featuresPaths: Array<string>): Features;
+declare function readFeaturesDirs(featuresPaths: Array<string>, isverbose?: boolean): Features;
 declare function getFeatureSpec(name: string, type: FeatureType): {
     found: boolean;
     path: string;

package/dist/state/features.js

@@ -1,7 +1,7 @@
 import { default as path } from "path";
 import { readFeaturesDir } from "../cmd/sys/read_features.js";
 import { readFeature } from "../db/read.js";
-function readFeaturesDirs(featuresPaths) {
+function readFeaturesDirs(featuresPaths, isverbose = false) {
     const feats = {
         task: [],
         action: [],
@@ -11,6 +11,9 @@ function readFeaturesDirs(featuresPaths) {
         agent: [],
     };
     featuresPaths.forEach((dir) => {
+        if (isverbose) {
+            console.log("Reading feats in", dir);
+        }
         const _f = readFeaturesDir(dir);
         _f.agent.forEach((item) => feats.agent.push(item));
         _f.task.forEach((item) => feats.task.push(item));

package/package.json

@@ -2,7 +2,7 @@
   "name": "@agent-smith/cli",
   "description": "Agent Smith: terminal client for language model agents",
   "repository": "https://github.com/synw/agent-smith",
-  "version": "0.0.105",
+  "version": "0.0.107",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,21 +10,22 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/agent": "^0.2.1",
-    "@agent-smith/task": "^0.2.1",
-    "@agent-smith/nodetask": "^0.1.0",
+    "@agent-smith/agent": "^0.2.2",
+    "@agent-smith/nodetask": "^0.1.1",
+    "@agent-smith/task": "^0.2.3",
     "@agent-smith/tfm": "^0.2.0",
     "@inquirer/prompts": "^8.2.0",
     "@intrinsicai/gbnfgen": "0.12.0",
     "@locallm/api": "^0.7.3",
-    "@modelcontextprotocol/sdk": "^1.25.2",
-    "@vue/reactivity": "^3.5.26",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@vue/reactivity": "^3.5.27",
     "ansi-colors": "^4.1.3",
-    "better-sqlite3": "^12.6.0",
-    "clipboardy": "^5.0.2",
+    "better-sqlite3": "^12.6.2",
+    "clipboardy": "^5.1.0",
     "commander": "^14.0.2",
     "marked-terminal": "^7.3.0",
-    "ora": "^9.0.0",
+    "modprompt": "0.13.1",
+    "ora": "^9.1.0",
     "python-shell": "^5.0.0",
     "yaml": "^2.8.2"
   },
@@ -36,11 +37,10 @@
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^25.0.8",
+    "@types/node": "^25.0.10",
     "openai": "^6.16.0",
     "restmix": "^0.6.1",
-    "rollup": "^4.55.1",
-    "ts-node": "^10.9.2",
+    "rollup": "^4.56.0",
     "tslib": "2.8.1",
     "typescript": "^5.9.3"
   },

package/dist/cmd/clicmds/cache.d.ts

@@ -1,4 +0,0 @@
-import { FeatureSpec } from '../../interfaces.js';
-declare function ensureUserCmdsCacheFileExists(cacheFilePath: string): string;
-declare function updateUserCmdsCache(cacheFilePath: string, cmdFeats: Array<FeatureSpec>): void;
-export { ensureUserCmdsCacheFileExists, updateUserCmdsCache, };

package/dist/cmd/clicmds/cache.js

@@ -1,39 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { runtimeError } from '../../utils/user_msgs.js';
-function createCacheFileContent(cmdFeats) {
-    const imports = new Array();
-    const cmdNames = new Array();
-    let i = 1;
-    cmdFeats.forEach(feat => {
-        const fileName = feat.name + "." + feat.ext;
-        const importPath = path.join(feat.path, fileName);
-        const cmdId = `c${i}`;
-        const line = `import { cmd as ${cmdId} } from "file://${importPath}";`;
-        imports.push(line);
-        cmdNames.push(cmdId);
-        ++i;
-    });
-    const finalImports = imports.join("\n");
-    const cmds = `const cmds = [ ${cmdNames.join(", ")} ];\nconst isCacheReady = true;`;
-    const end = "export { isCacheReady, cmds }";
-    return `${finalImports}\n\n${cmds}\n\n${end}`;
-}
-function ensureUserCmdsCacheFileExists(cacheFilePath) {
-    const fileExists = fs.existsSync(cacheFilePath);
-    if (!fileExists) {
-        fs.writeFileSync(cacheFilePath, "const cmds = [];\nexport { cmds }");
-    }
-    return cacheFilePath;
-}
-function updateUserCmdsCache(cacheFilePath, cmdFeats) {
-    const filePath = ensureUserCmdsCacheFileExists(cacheFilePath);
-    const cacheFileContent = createCacheFileContent(cmdFeats);
-    try {
-        fs.writeFileSync(filePath, cacheFileContent);
-    }
-    catch (err) {
-        runtimeError("Error writing to user commands cache file at " + filePath, `${err}`);
-    }
-}
-export { ensureUserCmdsCacheFileExists, updateUserCmdsCache, };