@agent-smith/cli 0.0.109 → 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

@@ -4,6 +4,7 @@ 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...]`)
@@ -12,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) {
@@ -34,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) {
@@ -49,6 +52,14 @@ function initCommandsFromAliases(program, aliases, features) {
                     }
                 }
                 break;
+            /*case "action":
+                const acmd = program.command(`${alias.name} [args...]`)
+                    .description("action: " + alias.name)
+                    .action(async (...args: Array<any>) => {
+                        await executeActionCmd(alias.name, args)
+                    });
+                allOptions.forEach(o => acmd.addOption(o));
+                break;*/
             case "workflow":
                 const wcmd = program.command(`${alias.name} [args...]`)
                     .description("workflow: " + alias.name)

package/dist/cmd/clicmds/base.js

@@ -5,6 +5,9 @@ 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.js

@@ -18,12 +18,14 @@ async function initUserCmds(cmdFeats, program) {
     const features = Object.values(cmdFeats);
     const usrCmds = [];
     for (const feat of features) {
+        //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) => {
@@ -43,6 +45,7 @@ async function initUserCmds(cmdFeats, program) {
                         cmd.addOption(new Option(opt[0], opt[1]));
                     }
                     else {
+                        // predefined option
                         switch (opt) {
                             case "all":
                                 allOptions.forEach(o => cmd.addOption(o));
@@ -64,6 +67,7 @@ async function initUserCmds(cmdFeats, program) {
         }
         usrCmds.push(cmd);
     }
+    //console.log("USRCMDS", usrCmds.map(c => c.name()))
     return usrCmds;
 }
 async function resetDbCmd() {
@@ -79,6 +83,7 @@ async function processTasksCmd(args, options) {
         if (!isTaskSettingsInitialized.value) {
             initTaskSettings();
         }
+        //console.log("PTS", tasksSettings);
         console.log(YAML.stringify({ "tasks": tasksSettings }));
     }
     else {
@@ -87,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;
@@ -101,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);
@@ -122,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, };

package/dist/cmd/clicmds/updateconf.js

@@ -42,6 +42,7 @@ async function updateFeaturesCmd(options) {
 }
 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) {

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,21 +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 => {
+        //console.log("Add cmd", c.name());
+        program.addCommand(c)
+    });
+    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) {