@agent-smith/cli 0.0.108 → 0.0.110

package/dist/cli.js

@@ -6,6 +6,7 @@ import { backend } from './state/backends.js';
 async function query(program) {
     const data = { message: "$", default: "" };
     const q = await input(data);
+    //console.log("QUERY", q);
     const args = q.split(" ");
     await program.parseAsync(args, { from: "user" });
     if (isChatMode.value) {

package/dist/cmd/clicmds/aliases.js

@@ -1,10 +1,10 @@
 import { allOptions } from "../options.js";
 import { executeTaskCmd } from "../lib/tasks/cmd.js";
-import { executeActionCmd } from "../lib/actions/cmd.js";
 import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
 import { executeAgentCmd } from "../lib/agents/cmd.js";
 function initCommandsFromAliases(program, aliases, features) {
     aliases.forEach((alias) => {
+        //console.log("A", alias)
         switch (alias.type) {
             case "agent":
                 const agcmd = program.command(`${alias.name} [prompt_and_vars...]`)
@@ -13,6 +13,7 @@ function initCommandsFromAliases(program, aliases, features) {
                     await executeAgentCmd(alias.name, args);
                 });
                 allOptions.forEach(o => agcmd.addOption(o));
+                //console.log("TVARS", alias.name, features.task[alias.name]?.variables)
                 if (features.agent[alias.name]?.variables) {
                     const rtv = features.agent[alias.name].variables?.required;
                     if (rtv) {
@@ -35,6 +36,7 @@ function initCommandsFromAliases(program, aliases, features) {
                     await executeTaskCmd(alias.name, args);
                 });
                 allOptions.forEach(o => tcmd.addOption(o));
+                //console.log("TVARS", alias.name, features.task[alias.name]?.variables)
                 if (features.task[alias.name]?.variables) {
                     const rtv = features.task[alias.name].variables?.required;
                     if (rtv) {
@@ -50,14 +52,14 @@ function initCommandsFromAliases(program, aliases, features) {
                     }
                 }
                 break;
-            case "action":
+            /*case "action":
                 const acmd = program.command(`${alias.name} [args...]`)
                     .description("action: " + alias.name)
-                    .action(async (...args) => {
-                    await executeActionCmd(alias.name, args);
-                });
+                    .action(async (...args: Array<any>) => {
+                        await executeActionCmd(alias.name, args)
+                    });
                 allOptions.forEach(o => acmd.addOption(o));
-                break;
+                break;*/
             case "workflow":
                 const wcmd = program.command(`${alias.name} [args...]`)
                     .description("workflow: " + alias.name)

package/dist/cmd/clicmds/base.js

@@ -1,10 +1,13 @@
 import { Option } from "commander";
 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 { processTaskCmd, processTasksCmd, resetDbCmd } from "./cmds.js";
+import { updateConfCmd, updateFeaturesCmd } from "./updateconf.js";
 import { displayOptions, inferenceOptions } from "../options.js";
 function initBaseCommands(program) {
+    /*program.command("ping")
+        .description("ping inference servers")
+        .action(async (...args: Array<any>) => { console.log("Found working inference server(s):", await initAgent(initRemoteBackends())) });*/
     program.command("exit")
         .description("exit the cli")
         .action(() => process.exit(0));

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

@@ -1,8 +1,7 @@
 import { Command } from 'commander';
 import { FeatureSpec } from '../../interfaces.js';
-declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>): Promise<Array<Command>>;
+declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>, program: Command): Promise<Array<Command>>;
 declare function resetDbCmd(): 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 };
+export { initUserCmds, processTaskCmd, processTasksCmd, resetDbCmd, };

package/dist/cmd/clicmds/cmds.js

@@ -1,26 +1,73 @@
 import colors from "ansi-colors";
+import { Option } from 'commander';
 import path from "path";
 import YAML from 'yaml';
 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";
-import { readPluginsPaths } from "../../state/plugins.js";
+import { readFeaturesType, readTaskSetting } from "../../db/read.js";
+import { deleteTaskSetting, upsertTaskSettings } from "../../db/write.js";
+import { getFeatureSpec } from "../../state/features.js";
 import { runMode } from "../../state/state.js";
 import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from '../../state/tasks.js';
 import { deleteFileIfExists } from "../sys/delete_file.js";
-import { readCmd } from "../sys/read_cmds.js";
 import { readTask } from "../sys/read_task.js";
-async function initUserCmds(cmdFeats) {
+import { parseCommandArgs } from "../lib/options_parsers.js";
+import { readCmd } from "../sys/read_cmds.js";
+import { runtimeDataError } from "../lib/user_msgs.js";
+import { allOptions, displayOptions, inferenceOptions, ioOptions } from "../options.js";
+async function initUserCmds(cmdFeats, program) {
     const features = Object.values(cmdFeats);
     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);
+        //console.log("Init cmd", feat);
+        const hasVariables = feat?.variables ? true : false;
+        const vars = hasVariables ? feat.variables : {};
+        let desc = "";
+        if (hasVariables) {
+            desc = vars.description;
         }
+        // @ts-ignore
+        const cmd = program.command(feat.variables.name)
+            .description(desc)
+            .action(async (...args) => {
+            const ca = parseCommandArgs(args);
+            const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+            const c = await readCmd(feat.name, cmdPath);
+            if (!c) {
+                runtimeDataError(`can not import command ${feat.name}`);
+                throw new Error();
+            }
+            await c.run(ca.args, ca.options);
+        });
+        if (hasVariables) {
+            if (vars?.options) {
+                for (const opt of vars.options) {
+                    if (Array.isArray(opt)) {
+                        cmd.addOption(new Option(opt[0], opt[1]));
+                    }
+                    else {
+                        // predefined option
+                        switch (opt) {
+                            case "all":
+                                allOptions.forEach(o => cmd.addOption(o));
+                                break;
+                            case "display":
+                                displayOptions.forEach(o => cmd.addOption(o));
+                                break;
+                            case "inference":
+                                inferenceOptions.forEach(o => cmd.addOption(o));
+                                break;
+                            case "io":
+                                ioOptions.forEach(o => cmd.addOption(o));
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        usrCmds.push(cmd);
     }
+    //console.log("USRCMDS", usrCmds.map(c => c.name()))
     return usrCmds;
 }
 async function resetDbCmd() {
@@ -31,23 +78,12 @@ async function resetDbCmd() {
     deleteFileIfExists(dbPath);
     console.log("Config database reset ok. Run the conf command to recreate it");
 }
-async function updateFeaturesCmd(options) {
-    const fp = readFeaturePaths();
-    const pp = await readPluginsPaths();
-    const paths = [...fp, ...pp];
-    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);
-    }
-}
 async function processTasksCmd(args, options) {
     if (options?.conf) {
         if (!isTaskSettingsInitialized.value) {
             initTaskSettings();
         }
+        //console.log("PTS", tasksSettings);
         console.log(YAML.stringify({ "tasks": tasksSettings }));
     }
     else {
@@ -56,6 +92,7 @@ async function processTasksCmd(args, options) {
     }
 }
 async function processTaskCmd(args, options) {
+    //console.log("TASK OPTS", options);
     if (args.length == 0) {
         console.warn("Provide a task name");
         return;
@@ -70,10 +107,12 @@ async function processTaskCmd(args, options) {
         console.log("Task", args[0], "reset ok");
         return;
     }
+    //console.log("RT", path)
     const res = readTask(path);
     if (!res.found) {
         throw new Error(`Task ${args[0]}, ${path} not found`);
     }
+    //const ts = JSON.parse(res.ymlTask);
     console.log(res.ymlTask);
     if (Object.keys(options).length > 0) {
         upsertTaskSettings(args[0], options);
@@ -91,5 +130,6 @@ async function processTaskCmd(args, options) {
         }
         console.log(colors.dim("Settings") + ":", display);
     }
+    //console.log(JSON.stringify(ts, null, "  "));
 }
-export { initUserCmds, processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd };
+export { initUserCmds, processTaskCmd, processTasksCmd, resetDbCmd, };

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

@@ -1,2 +1,3 @@
+declare function updateFeaturesCmd(options: Record<string, any>): Promise<any>;
 declare function updateConfCmd(args: Array<string>): Promise<any>;
-export { updateConfCmd, };
+export { updateConfCmd, updateFeaturesCmd, };

package/dist/cmd/clicmds/updateconf.js

@@ -1,12 +1,48 @@
+import path from "path";
 import { processConfPath } from "../../conf.js";
 import { initDb } from "../../db/db.js";
-import { readFilePath } from "../../db/read.js";
+import { readFeaturePaths, readFilePath } from "../../db/read.js";
 import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, updatePromptfilePath, upsertFilePath } from "../../db/write.js";
 import { readFeaturesDirs } from "../../state/features.js";
+import { readPluginsPaths } from "../../state/plugins.js";
 import { dataDirPath, promptfilePath } from "../../state/state.js";
 import { runtimeDataError, runtimeInfo } from '../lib/user_msgs.js';
+import { readUserCmd } from "../sys/read_cmds.js";
+async function getUserCmdsData(feats) {
+    for (const feat of feats.cmd) {
+        const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+        const { found, userCmd } = await readUserCmd(feat.name, cmdPath);
+        if (found) {
+            feat.variables = {
+                description: userCmd.description,
+                name: userCmd.name,
+            };
+            if (userCmd?.options) {
+                feat.variables.options = userCmd.options;
+            }
+        }
+    }
+    return feats;
+}
+async function updateAllFeatures(paths) {
+    let feats = readFeaturesDirs(paths, true);
+    feats = await getUserCmdsData(feats);
+    updateFeatures(feats);
+    updateAliases(feats);
+    const deleted = cleanupFeaturePaths(paths);
+    for (const el of deleted) {
+        console.log("- [feature path]", el);
+    }
+}
+async function updateFeaturesCmd(options) {
+    const fp = readFeaturePaths();
+    const pp = await readPluginsPaths();
+    const paths = [...fp, ...pp];
+    updateAllFeatures(paths);
+}
 async function updateConfCmd(args) {
     initDb(false, true);
+    // try to find a conf path in db
     const { found, path } = readFilePath("conf");
     const userProvidedConfPath = (args[0] != "conf") ? args[0] : null;
     if (!found && !userProvidedConfPath) {
@@ -33,12 +69,6 @@ async function updateConfCmd(args) {
         updateDataDirPath(dd);
         dataDirPath.value = dd;
     }
-    const feats = readFeaturesDirs(paths, true);
-    updateFeatures(feats);
-    updateAliases(feats);
-    const deleted = cleanupFeaturePaths(paths);
-    for (const el of deleted) {
-        console.log("- [feature path]", el);
-    }
+    updateAllFeatures(paths);
 }
-export { updateConfCmd, };
+export { updateConfCmd, updateFeaturesCmd, };

package/dist/cmd/cmds.js

@@ -7,8 +7,11 @@ import { isChatMode, runMode } from "../state/state.js";
 import { initCommandsFromAliases } from "./clicmds/aliases.js";
 import { initBaseCommands } from "./clicmds/base.js";
 import { initUserCmds } from "./clicmds/cmds.js";
+import { exit } from "node:process";
+//import { usePerfTimer } from "../main.js";
 const program = new Command();
 async function chat(program, options, agent, mcpServers) {
+    //console.log("CHAT OPTS", options);
     const data = { message: '>', default: "" };
     const prompt = await input(data);
     if (prompt == "/q") {
@@ -21,24 +24,88 @@ async function chat(program, options, agent, mcpServers) {
             await query(program);
         }
     }
+    //console.log("CHAT HIST", agent.history);
+    //options.history = undefined;
+    //console.log("RUN W PROMPT", prompt);
     await agent.run(prompt, chatInferenceParams, options, chatTemplate ? chatTemplate : undefined);
     console.log();
     await chat(program, options, agent, mcpServers);
 }
 async function buildCmds() {
+    //program.allowUnknownOption(true);
+    //const perf = usePerfTimer();
     initBaseCommands(program);
+    //perf.measure("initBaseCommands");
     const aliases = readAliases();
+    //perf.measure("readAliases");
     const feats = readFeatures();
+    //perf.measure("readFeatures");
     initCommandsFromAliases(program, aliases, feats);
+    //perf.measure("initCommandsFromAliases");
+    await initUserCmds(feats.cmd, program);
+    //perf.measure("initUserCmds");
+    //perf.measure("cmds for each");
+    //perf.final("buildCmds");
+    return program;
+}
+/*async function buildCmds(): Promise<Command> {
+    // Performance measurement start
+    const startTime = process.hrtime.bigint();
+    const measurements: { name: string; time: number; percentage: number }[] = [];
+    let lastTime = startTime;
+
+    function measureFunction(name: string) {
+        const currentTime = process.hrtime.bigint();
+        const elapsedNs = Number(currentTime - lastTime);
+        const elapsedSec = elapsedNs / 1_000_000_000;
+        measurements.push({ name, time: elapsedSec, percentage: 0 });
+        lastTime = currentTime;
+    }
+
+    //program.allowUnknownOption(true);
+    measureFunction("start");
+    initBaseCommands(program);
+
+    measureFunction("initBaseCommands");
+    const aliases = readAliases();
+
+    measureFunction("readAliases");
+    const feats = readFeatures();
+
+    measureFunction("readFeatures");
+    initCommandsFromAliases(program, aliases, feats);
+
+    measureFunction("initCommandsFromAliases");
     const cmds = await initUserCmds(feats.cmd);
+
+    measureFunction("initUserCmds");
     cmds.forEach(c => {
-        program.addCommand(c);
+        //console.log("Add cmd", c.name());
+        program.addCommand(c)
     });
-    return program;
-}
+    measureFunction("cmds.forEach");
+
+    // Calculate percentages and display results
+    const totalTime = Number(process.hrtime.bigint() - startTime) / 1_000_000_000;
+    measurements.forEach(m => {
+        m.percentage = (m.time / totalTime) * 100;
+    });
+
+    console.log("\nPerformance Measurements for buildCmds:");
+    measurements.forEach(m => {
+        console.log(`${m.name}: ${m.time.toFixed(6)}s (${m.percentage.toFixed(2)}%)`);
+    });
+    console.log(`Total time: ${totalTime.toFixed(6)}s\n`);
+
+    return program
+}*/
 async function parseCmd(program) {
     program.name('Agent Smith terminal client');
     program.description('Terminal agents toolkit');
     await program.parseAsync();
+    exit(0);
+    /*if (isChatMode.value) {
+        await chat(program)
+    }*/
 }
 export { buildCmds, chat, parseCmd, program };

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

@@ -12,6 +12,7 @@ import { pathToFileURL } from 'url';
 import { getInputFromOptions } from '../tasks/utils.js';
 async function executeAction(name, payload, options, quiet = false) {
     let run;
+    //console.log("GET ACTION", name, payload);
     const inputData = await getInputFromOptions(options);
     if (inputData) {
         if (Array.isArray(payload)) {
@@ -22,11 +23,14 @@ async function executeAction(name, payload, options, quiet = false) {
     if (!found) {
         throw new Error(`Action ${name} not found at ${path}`);
     }
+    //console.log("CREATE ACTION", name, ext, path);
     switch (ext) {
         case "js":
             const url = pathToFileURL(path).href;
-            const mjsa = await import(url);
+            //console.log("CR JSA", url);
+            const mjsa = await import(/* @vite-ignore */ url);
             run = createJsAction(mjsa.action);
+            //console.log("END CR JSA")
             break;
         case "yml":
             run = systemAction(path);
@@ -37,6 +41,7 @@ async function executeAction(name, payload, options, quiet = false) {
         default:
             throw new Error(`Action ext ${ext} not implemented`);
     }
+    //console.log("RUN", payload);
     const res = await run(payload, options);
     if (!quiet) {
         if (res) {
@@ -47,7 +52,9 @@ async function executeAction(name, payload, options, quiet = false) {
     return res;
 }
 async function executeActionCmd(name, aargs, quiet = false) {
+    //console.log("AARGs", aargs)
     const { args, options } = parseCommandArgs(aargs);
+    //console.log("CMDA", args)
     const params = args;
     if (options?.clipBoardInput) {
         params.push(await readClipboard());
@@ -62,9 +69,12 @@ async function executeActionCmd(name, aargs, quiet = false) {
 }
 function systemAction(path) {
     const run = async (params) => {
+        //console.log("SYS ACTION PARAMS", params);
         let runArgs = new Array();
+        // convert args for tool calls
         if (!Array.isArray(params)) {
             try {
+                // obviously a tool call
                 if (typeof params == "string") {
                     runArgs.push(params);
                 }
@@ -83,9 +93,12 @@ function systemAction(path) {
         if (!actionSpec.found) {
             runtimeError("System action yml file", path, "not found");
         }
+        //console.log("Yml action", JSON.stringify(actionSpec.data, null, "  "));
+        //console.log("Args", args)
         if (!actionSpec.data?.args) {
             actionSpec.data.args = [];
         }
+        //console.log("EXEC", actionSpec.data.cmd, [...actionSpec.data.args, ...runArgs]);
         const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...runArgs]);
         return out.trim();
     };
@@ -93,9 +106,11 @@ function systemAction(path) {
 }
 function pythonAction(path) {
     const run = async (params) => {
+        //console.log("PY ACTION PARAMS", params);
         let runArgs = new Array();
         if (!Array.isArray(params)) {
             try {
+                // obviously a tool call
                 if (typeof params == "string") {
                     runArgs.push(params);
                 }
@@ -110,7 +125,11 @@ function pythonAction(path) {
         else {
             runArgs = params;
         }
+        //console.log("Py action", path);
         const { data, error } = await runPyScript(pyShell, "python3", path, runArgs);
+        /*console.log("----------------");
+        console.log("PYOUT", data);
+        console.log("----------------");*/
         if (error) {
             throw new Error(`python error: ${error}`);
         }
@@ -125,6 +144,7 @@ function pythonAction(path) {
             }
             catch (e) {
                 console.warn("Can not parse json from python action", path, e);
+                //throw new Error(`python error: ${error}`) 
             }
         }
         return final;

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

@@ -1,10 +1,14 @@
 function createJsAction(action) {
     const run = async (args, options) => {
+        //console.log("JS ACTION PARAMS", args);
         try {
             const res = await action(args, options);
             return res;
         }
         catch (e) {
+            /*if (e?.text) {
+                throw new Error(`executing action:${e.text()}. Args: ${args}`);
+            }*/
             throw new Error(`executing action:${e}. Args: ${args}`);
         }
     };

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

@@ -3,6 +3,9 @@ import { createJsAction } from "../actions/read.js";
 import { pathToFileURL } from 'url';
 import { getInputFromOptions } from "../tasks/utils.js";
 async function executeAdaptater(name, params, options) {
+    /*if (params?.args) {
+        params = params.args;
+    }*/
     const { found, path } = getFeatureSpec(name, "adaptater");
     if (!found) {
         throw new Error(`adaptater ${name} not found`);
@@ -15,11 +18,13 @@ async function executeAdaptater(name, params, options) {
     }
     let run;
     const url = pathToFileURL(path).href;
-    const jsa = await import(url);
+    const jsa = await import(/* @vite-ignore */ url);
     run = createJsAction(jsa.action);
     let res;
     try {
+        //console.log("ADAPT RUN PARAMS", params);
         res = await run(params, options);
+        //console.log("ADAPT RES", res);
     }
     catch (e) {
         throw new Error(`adaptater ${name}: ${e}`);
@@ -27,6 +32,8 @@ async function executeAdaptater(name, params, options) {
     if (res?.error) {
         throw res.error;
     }
+    //await processOutput(res);
+    //console.log("ADRES", res);
     return res;
 }
 export { executeAdaptater, };

package/dist/cmd/lib/agents/cmd.js

@@ -5,6 +5,7 @@ async function executeAgentCmd(name, targs = []) {
     const ca = parseCommandArgs(targs);
     const prompt = await getTaskPrompt(name, ca.args, ca.options);
     ca.options.isAgent = true;
-    return await executeTask(name, { prompt: prompt }, ca.options);
+    const res = await executeTask(name, { prompt: prompt }, ca.options);
+    return res;
 }
 export { executeAgentCmd, };

package/dist/cmd/lib/mcp.js

@@ -9,6 +9,9 @@ class McpClient {
     askUserTools = null;
     tools = {};
     constructor(servername, command, args, authorizedTools = null, askUserTools = null) {
+        //console.log("MCP servername", servername);
+        //console.log("MCP command", command);
+        //console.log("MCP ARGS", typeof args, args);
         this.name = servername;
         const okargs = new Array();
         for (const arg of args) {
@@ -59,7 +62,9 @@ class McpClient {
                     argsTypes[k] = vv.type;
                 }
             }
+            //console.log("MCP ARGS TYPES", argsTypes);
             const exec = async (args) => {
+                //console.log("MCP EXEC ARGS", args);
                 const _iargs = args;
                 for (const [k, v] of Object.entries(_iargs)) {
                     if (argsTypes[k] == "array") {
@@ -76,6 +81,7 @@ class McpClient {
                     name: tool.name,
                     arguments: _iargs,
                 };
+                //console.log("PAY", payload);
                 const res = await this.client.callTool(payload);
                 return res;
             };

package/dist/cmd/lib/options_parsers.js

@@ -1,11 +1,16 @@
 function parseCommandArgs(args) {
+    //return { args: program.args, options: program.opts() }
+    //discard the command (last arg)
     args.pop();
+    //console.log("Raw command args:", args);
     const res = {
         args: new Array(),
         options: {},
     };
     res.options = args.pop();
     res.args = Array.isArray(args[0]) ? args[0] : args;
+    //console.log("PARSE ARGS RES", res.args);
+    //console.log("PARSE OPTS RES", res.options);
     return res;
 }
 function parseTaskConfigOptions(options) {