@agent-smith/cli 0.0.106 → 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,7 +1,7 @@
 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 { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
@@ -11,7 +11,6 @@ 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);
     const usrCmds = [];
@@ -32,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}`);

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) {
@@ -177,7 +181,9 @@ async function executeTask(name, payload, options) {
                 }
             }
             if (!options?.quiet) {
-                printToken(t);
+                if (!options?.isToolCall || (options?.debug || options.verbose)) {
+                    printToken(t);
+                }
             }
         }
         ++emittedTokens;
@@ -226,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")) {

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.js

@@ -5,7 +5,7 @@ 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 { getInputFromOptions, getTaskPrompt } from "../tasks/utils.js";
 import { runtimeError } from "../user_msgs.js";
 import { readWorkflow } from "./read.js";
 async function executeWorkflow(wname, args, options = {}) {
@@ -51,6 +51,7 @@ async function executeWorkflow(wname, args, options = {}) {
                     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 };
                 }
@@ -92,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}`);
@@ -110,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}`);
@@ -138,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;
                     }

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/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.106",
+  "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/nodetask": "^0.1.0",
-    "@agent-smith/task": "^0.2.2",
+    "@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",
+    "@modelcontextprotocol/sdk": "^1.25.3",
     "@vue/reactivity": "^3.5.27",
     "ansi-colors": "^4.1.3",
     "better-sqlite3": "^12.6.2",
-    "clipboardy": "^5.0.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.9",
+    "@types/node": "^25.0.10",
     "openai": "^6.16.0",
     "restmix": "^0.6.1",
-    "rollup": "^4.55.2",
-    "ts-node": "^1.7.1",
+    "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, };