@agent-smith/cli 0.0.62 → 0.0.64

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

@@ -5,24 +5,74 @@ import { execute } from "../../sys/execute.js";
 import { runPyScript } from "../../sys/run_python.js";
 import { pyShell } from "../../../state/state.js";
 import { createJsAction } from "./read.js";
+import { runtimeError } from "../../../utils/user_msgs.js";
+import { readClipboard } from "../../sys/clipboard.js";
+import { processOutput, readPromptFile } from "../utils.js";
+import { parseCommandArgs } from "../options_parsers.js";
+async function executeAction(name, payload, options, quiet = false) {
+    let act;
+    const { found, path, ext } = getFeatureSpec(name, "action");
+    if (!found) {
+        throw new Error(`Action ${name} not found at ${path}`);
+    }
+    switch (ext) {
+        case "js":
+            const mjsa = await import(path);
+            act = createJsAction(mjsa.action);
+            break;
+        case "yml":
+            act = systemAction(path);
+            break;
+        case "py":
+            act = pythonAction(path);
+            break;
+        default:
+            throw new Error(`Action ext ${ext} not implemented`);
+    }
+    const res = await act.run(payload, options);
+    if (!quiet) {
+        if (res) {
+            console.log(res);
+        }
+    }
+    await processOutput(res);
+    return res;
+}
+async function executeActionCmd(name, aargs, quiet = false) {
+    const { args, options } = parseCommandArgs(aargs);
+    const params = { args: args };
+    if (options?.clipBoardInput) {
+        params.args.push(await readClipboard());
+    }
+    else if (options?.inputFile) {
+        params.args.push(readPromptFile());
+    }
+    if (options?.debug) {
+        console.log("Action", name, "params", params);
+    }
+    return await executeAction(name, params, options, quiet);
+}
 function systemAction(path) {
     const action = useAgentTask({
         id: "system_action",
         title: "",
-        run: async (args) => {
+        run: async (params) => {
             let runArgs = new Array();
-            if (!Array.isArray(args)) {
+            if (params?.args) {
+                runArgs = params.args;
+            }
+            else {
                 try {
-                    runArgs = Object.values(args);
+                    runArgs = Object.values(params);
                 }
                 catch (e) {
                     throw new Error(`wrong system action args: ${e}`);
                 }
             }
-            else {
-                runArgs = args;
-            }
             const actionSpec = readYmlFile(path);
+            if (!actionSpec.found) {
+                runtimeError("System action yml file", path, "not found");
+            }
             if (!actionSpec.data?.args) {
                 actionSpec.data.args = [];
             }
@@ -36,8 +86,20 @@ function pythonAction(path) {
     const action = useAgentTask({
         id: "python_action",
         title: "",
-        run: async (args) => {
-            const { data, error } = await runPyScript(pyShell, "python3", path, args);
+        run: async (params) => {
+            let runArgs = new Array();
+            if (params?.args) {
+                runArgs = params.args;
+            }
+            else {
+                try {
+                    runArgs = Object.values(params);
+                }
+                catch (e) {
+                    throw new Error(`wrong python action args: ${e}`);
+                }
+            }
+            const { data, error } = await runPyScript(pyShell, "python3", path, runArgs);
             if (error) {
                 throw new Error(`python error: ${error}`);
             }
@@ -58,44 +120,4 @@ function pythonAction(path) {
     });
     return action;
 }
-async function executeActionCmd(args = [], options = {}, quiet = false) {
-    const isWorkflow = !Array.isArray(args);
-    let name;
-    if (!isWorkflow) {
-        name = args.shift();
-    }
-    else {
-        if (!args.name) {
-            throw new Error("Provide an action name param");
-        }
-        name = args.name;
-        delete args.name;
-    }
-    const { found, path, ext } = getFeatureSpec(name, "action");
-    if (!found) {
-        throw new Error(`Action ${name} not found at ${path}`);
-    }
-    let act;
-    switch (ext) {
-        case "js":
-            const mjsa = await import(path);
-            act = createJsAction(mjsa.action);
-            break;
-        case "yml":
-            act = systemAction(path);
-            break;
-        case "py":
-            act = pythonAction(path);
-            break;
-        default:
-            throw new Error(`Action ext ${ext} not implemented`);
-    }
-    const res = await act.run(args, options);
-    if (!quiet) {
-        if (res) {
-            console.log("ARES", res);
-        }
-    }
-    return res;
-}
-export { executeActionCmd, systemAction, pythonAction };
+export { executeAction, executeActionCmd, systemAction, pythonAction, };

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

@@ -3,9 +3,9 @@ function createJsAction(action) {
     const task = useAgentTask({
         id: "",
         title: "",
-        run: async (args) => {
+        run: async (args, options) => {
             try {
-                const res = await action(args);
+                const res = await action(args, options);
                 return res;
             }
             catch (e) {

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

@@ -1,2 +1,2 @@
-declare function executeAdaptaterCmd(args?: Array<string> | Record<string, any>, options?: any): Promise<any>;
-export { executeAdaptaterCmd, };
+declare function executeAdaptater(name: string, argsOrParams: Record<string, any> | Array<any>, options: Record<string, any>): Promise<any>;
+export { executeAdaptater, };

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

@@ -1,18 +1,6 @@
 import { getFeatureSpec } from "../../../state/features.js";
 import { createJsAction } from "../actions/read.js";
-async function executeAdaptaterCmd(args = [], options = {}) {
-    const isWorkflow = !Array.isArray(args);
-    let name;
-    if (!isWorkflow) {
-        name = args.shift();
-    }
-    else {
-        if (!args.name) {
-            throw new Error("provide an adaptater name param");
-        }
-        name = args.name;
-        delete args.name;
-    }
+async function executeAdaptater(name, argsOrParams, options) {
     const { found, path } = getFeatureSpec(name, "adaptater");
     if (!found) {
         throw new Error(`adaptater ${name} not found`);
@@ -22,7 +10,7 @@ async function executeAdaptaterCmd(args = [], options = {}) {
     act = createJsAction(jsa.action);
     let res;
     try {
-        res = await act.run(args, options);
+        res = await act.run(argsOrParams, options);
     }
     catch (e) {
         throw new Error(`adaptater ${name}: ${e}`);
@@ -32,4 +20,4 @@ async function executeAdaptaterCmd(args = [], options = {}) {
     }
     return res;
 }
-export { executeAdaptaterCmd, };
+export { executeAdaptater, };

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

@@ -1,3 +1,3 @@
-declare function showModelsCmd(args: Array<string>, options: any): Promise<void>;
+declare function showModelsCmd(args: Array<string>): Promise<void>;
 declare function updateAllModels(): void;
 export { updateAllModels, showModelsCmd, };

package/dist/cmd/lib/models.js

@@ -3,19 +3,21 @@ import { readModelfiles, readModels } from "../../db/read.js";
 import { readModelsFile } from "../sys/read_modelfile.js";
 import { updateModels as dbUpdateModels } from "../../db/write.js";
 import color from "ansi-colors";
-async function showModelsCmd(args, options) {
+async function showModelsCmd(args) {
     let models = readModels();
     models.sort((a, b) => a.name.localeCompare(b.name));
+    let foundModels = new Array();
     if (args.length > 0) {
         args.forEach((a) => {
-            models = models.filter((m) => m.shortname.includes(a) || m.name.includes(a));
+            const fm = models.filter((m) => m.shortname.includes(a) || m.name.includes(a));
+            foundModels.push(...fm);
         });
     }
-    models.forEach((model) => {
+    else {
+        foundModels = models;
+    }
+    foundModels.forEach((model) => {
         const ips = model.data.inferParams;
-        if (!ips?.max_tokens) {
-            throw new Error(`no max tokens in ${model.shortname}`);
-        }
         const mt = ips.max_tokens;
         delete ips.max_tokens;
         const vip = Object.keys(ips).length > 0 ? JSON.stringify(ips) : "";

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

@@ -0,0 +1,7 @@
+import { LmTaskConfig } from "../../interfaces.js";
+declare function parseCommandArgs(args: Array<any>): {
+    args: Array<any>;
+    options: Record<string, any>;
+};
+declare function parseTaskConfigOptions(options: Record<string, any>): LmTaskConfig;
+export { parseCommandArgs, parseTaskConfigOptions, };

package/dist/cmd/lib/options_parsers.js

@@ -0,0 +1,41 @@
+function parseCommandArgs(args) {
+    const res = {
+        args: new Array(),
+        options: {},
+    };
+    args.pop();
+    res.options = args.pop();
+    res.args = Array.isArray(args[0]) ? args[0] : args;
+    return res;
+}
+function parseTaskConfigOptions(options) {
+    const conf = { inferParams: {}, modelname: "", templateName: "" };
+    const optionsInferParams = {};
+    if (options?.temperature) {
+        optionsInferParams.temperature = options.temperature;
+    }
+    if (options?.top_k !== undefined) {
+        optionsInferParams.top_k = options.top_k;
+    }
+    if (options?.top_p !== undefined) {
+        optionsInferParams.top_p = options.top_p;
+    }
+    if (options?.min_p !== undefined) {
+        optionsInferParams.min_p = options.min_p;
+    }
+    if (options?.max_tokens !== undefined) {
+        optionsInferParams.max_tokens = options.max_tokens;
+    }
+    if (options?.repeat_penalty !== undefined) {
+        optionsInferParams.repeat_penalty = options.repeat_penalty;
+    }
+    if (options?.model !== undefined) {
+        conf.modelname = options.model;
+    }
+    if (options?.template !== undefined) {
+        conf.templateName = options.template;
+    }
+    conf.inferParams = optionsInferParams;
+    return conf;
+}
+export { parseCommandArgs, parseTaskConfigOptions, };

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

@@ -1,3 +1,4 @@
 import { LmTaskOutput } from "@agent-smith/lmtask";
-declare function executeTaskCmd(args?: Array<string> | Record<string, any>, options?: Record<string, any>): Promise<LmTaskOutput>;
-export { executeTaskCmd };
+declare function executeTask(name: string, payload: Record<string, any>, options: Record<string, any>, quiet?: boolean): Promise<LmTaskOutput>;
+declare function executeTaskCmd(name: string, targs?: Array<any>): Promise<LmTaskOutput>;
+export { executeTask, executeTaskCmd };

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

@@ -1,55 +1,46 @@
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
+import color from "ansi-colors";
 import ora from 'ora';
 import { brain, initAgent, taskBuilder } from "../../../agent.js";
+import { readClipboard } from "../../../cmd/sys/clipboard.js";
 import { readTool } from "../../../db/read.js";
-import { isChatMode, isDebug, isQuiet, isShowTokens, isVerbose } from "../../../state/state.js";
-import { parseArgs } from "../../../utils/args.js";
-import { executeActionCmd, } from "../actions/cmd.js";
-import { formatStats, parseInputOptions } from "../utils.js";
-import { executeWorkflowCmd } from "../workflows/cmd.js";
-import { configureTaskModel, mergeConfOptions, mergeInferParams } from "./conf.js";
+import { usePerfTimer } from "../../../main.js";
+import { isChatMode } from "../../../state/state.js";
+import { executeAction } from "../actions/cmd.js";
+import { parseCommandArgs, parseTaskConfigOptions } from "../options_parsers.js";
+import { runtimeDataError } from "../user_msgs.js";
+import { formatStats, readPromptFile } from "../utils.js";
+import { executeWorkflow } from "../workflows/cmd.js";
+import { configureTaskModel, mergeInferParams } from "./conf.js";
 import { openTaskSpec } from "./utils.js";
-async function executeTaskCmd(args = [], options = {}) {
+async function executeTask(name, payload, options, quiet = false) {
     await initAgent();
-    if (isDebug.value) {
-        console.log("Task args:", args);
+    if (options.debug) {
+        console.log("Payload:", payload);
         console.log("Task options:", options);
     }
-    const isWorkflow = !Array.isArray(args);
-    let name;
-    let pr;
-    if (!isWorkflow) {
-        name = args.shift();
-        const _pr = await parseInputOptions(options);
-        if (!_pr) {
-            const p = args.shift();
-            if (p) {
-                pr = p;
-            }
-            else {
-                throw new Error("Please provide a prompt");
-            }
-        }
-        else {
-            pr = _pr;
-        }
-    }
-    else {
-        if (!(args?.name)) {
-            throw new Error("Provide a task name param");
-        }
-        if (!(args?.prompt)) {
-            throw new Error("Provide a task prompt param");
-        }
-        name = args.name;
-        pr = args.prompt;
-    }
     const taskFileSpec = openTaskSpec(name);
-    let { conf, vars } = parseArgs(args, true);
-    conf = mergeConfOptions(conf, options);
+    const conf = parseTaskConfigOptions(options);
+    if (options.debug) {
+        console.log("conf:", conf);
+    }
     conf.inferParams = mergeInferParams(conf.inferParams, taskFileSpec.inferParams ?? {});
     const model = configureTaskModel(conf, taskFileSpec);
+    if (options?.ctx) {
+        model.ctx = options.ctx;
+    }
     const taskSpec = taskFileSpec;
+    let vars = {};
+    taskSpec.variables?.optional?.forEach(k => {
+        if (k in options) {
+            vars[k] = options[k];
+        }
+    });
+    taskSpec.variables?.required?.forEach(k => {
+        if (k in options) {
+            vars[k] = options[k];
+        }
+    });
     if (taskSpec.toolsList) {
         taskSpec.tools = [];
         for (const toolName of taskSpec.toolsList) {
@@ -59,21 +50,17 @@ async function executeTaskCmd(args = [], options = {}) {
             }
             const lmTool = {
                 ...tool,
-                execute: async (args) => {
-                    const normalizedArgs = Array.isArray(args) ? [toolName, ...args] : {
-                        name: toolName,
-                        ...args,
-                    };
+                execute: async (params) => {
                     switch (type) {
                         case "action":
-                            const res = await executeActionCmd(normalizedArgs, conf, true);
+                            const res = await executeAction(toolName, params, options, true);
                             return res;
                         case "task":
-                            conf.quiet = !isDebug.value;
-                            const tres = await executeTaskCmd(normalizedArgs, conf);
+                            conf.quiet = !options?.debug;
+                            const tres = await executeTask(name, params, options, true);
                             return tres.answer.text;
                         case "workflow":
-                            const wres = await executeWorkflowCmd(toolName, normalizedArgs, conf);
+                            const wres = await executeWorkflow(toolName, params, options);
                             return wres;
                         default:
                             throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
@@ -90,9 +77,8 @@ async function executeTaskCmd(args = [], options = {}) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
     }
-    if (isDebug.value) {
+    if (options.debug) {
         console.log("Task model:", model);
-        console.log("Task vars:", vars);
     }
     const ex = brain.getOrCreateExpertForModel(model.name, model.template);
     if (!ex) {
@@ -104,7 +90,7 @@ async function executeTaskCmd(args = [], options = {}) {
     const hasThink = ex.template?.tags?.think;
     const hasTools = ex.template?.tags?.toolCall;
     const printToken = (t) => {
-        if (isShowTokens.value) {
+        if (options?.tokens === true) {
             let txt = t;
             txt = c ? t : `\x1b[100m${t}\x1b[0m`;
             process.stdout.write(txt);
@@ -116,12 +102,24 @@ async function executeTaskCmd(args = [], options = {}) {
         }
     };
     let processToken = printToken;
-    if ((hasThink || hasTools) && !isDebug.value) {
+    if ((hasThink || hasTools) && !options?.debug) {
         let continueWrite = true;
         let skipNextEmptyLinesToken = false;
         const spinner = ora("Thinking ...");
+        const ts = "Thinking";
+        const te = color.dim("tokens");
+        const formatTokenCount = (i) => {
+            return `${ts} ${color.bold(i.toString())} ${te}`;
+        };
+        const perfTimer = usePerfTimer(false);
+        let i = 0;
         processToken = (t) => {
-            if (isQuiet.value) {
+            if (i == 0) {
+                perfTimer.start();
+            }
+            ++i;
+            spinner.text = formatTokenCount(i);
+            if (!options?.verbose) {
                 if (hasThink) {
                     if (t == ex.template.tags.think?.start) {
                         spinner.start();
@@ -131,7 +129,9 @@ async function executeTaskCmd(args = [], options = {}) {
                     else if (t == ex.template.tags.think?.end) {
                         continueWrite = true;
                         skipNextEmptyLinesToken = true;
-                        spinner.stop();
+                        let msg = color.dim("Thinking:") + ` ${i} ${color.dim("tokens")}`;
+                        msg = msg + " " + color.dim(perfTimer.time());
+                        spinner.info(msg);
                         return;
                     }
                 }
@@ -142,7 +142,7 @@ async function executeTaskCmd(args = [], options = {}) {
                     return;
                 }
                 else if (t == ex.template.tags.toolCall?.end) {
-                    if (isVerbose.value) {
+                    if (options?.verbose === true) {
                         skipNextEmptyLinesToken = true;
                         continueWrite = true;
                     }
@@ -162,7 +162,7 @@ async function executeTaskCmd(args = [], options = {}) {
         };
     }
     const onToolCall = (tc) => {
-        console.log("⚒️ ", `Executing [${name}]`, tc.name, tc.arguments);
+        console.log("⚒️ ", color.bold(name), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
     };
     if (options?.onToken) {
         ex.backend.setOnToken(options.onToken);
@@ -173,14 +173,14 @@ async function executeTaskCmd(args = [], options = {}) {
     const tconf = {
         expert: ex,
         model: model,
-        debug: isDebug.value,
+        debug: options.debug,
         onToolCall: onToolCall,
         ...conf,
     };
     tconf.expert = ex;
     let out;
     try {
-        out = await task.run({ prompt: pr, ...vars }, tconf);
+        out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
         if (!out.answer.text.endsWith("\n")) {
             console.log();
         }
@@ -192,11 +192,32 @@ async function executeTaskCmd(args = [], options = {}) {
         if (brain.ex.name != ex.name) {
             brain.setDefaultExpert(ex);
         }
-        brain.ex.template.pushToHistory({ user: pr, assistant: out.answer.text });
+        brain.ex.template.pushToHistory({ user: payload.prompt, assistant: out.answer.text });
     }
-    if (isDebug.value || isVerbose.value) {
+    if (options?.debug === true || options?.verbose === true) {
         console.log("\n", formatStats(out.answer.stats));
     }
     return out;
 }
-export { executeTaskCmd };
+async function executeTaskCmd(name, targs = []) {
+    const { args, options } = parseCommandArgs(targs);
+    let pr;
+    if (options?.clipboardInput === true) {
+        pr = await readClipboard();
+    }
+    else if (options?.inputFile === true) {
+        pr = readPromptFile();
+    }
+    else {
+        if (args[0] !== undefined) {
+            pr = args[0];
+        }
+        else {
+            runtimeDataError("task", name, "provide a prompt or use input options");
+            throw new Error();
+        }
+    }
+    const params = { args: args, prompt: pr };
+    return await executeTask(name, params, options);
+}
+export { executeTask, executeTaskCmd };

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

@@ -1,6 +1,13 @@
 import { FeatureExtension } from '../../interfaces.js';
+declare function extractTaskToolDocAndVariables(name: string, ext: FeatureExtension, dirPath: string): {
+    toolDoc: string;
+    variables: {
+        required: Array<string>;
+        optional: Array<string>;
+    };
+};
 declare function extractToolDoc(name: string, ext: FeatureExtension, dirPath: string): {
     found: boolean;
     toolDoc: string;
 };
-export { extractToolDoc, };
+export { extractToolDoc, extractTaskToolDocAndVariables, };

package/dist/cmd/lib/tools.js

@@ -58,6 +58,36 @@ function _parseToolDoc(rawTxt, name) {
         throw new Error(`Error parsing tool ${name}: data:\n${rawTxt}\n`);
     }
 }
+function _parseTaskVariables(data) {
+    const res = { required: new Array(), optional: new Array() };
+    if (data?.variables) {
+        if (data.variables?.required) {
+            res.required = data.variables.required;
+        }
+        if (data.variables?.optional) {
+            res.optional = data.variables.optional;
+        }
+    }
+    return res;
+}
+function extractTaskToolDocAndVariables(name, ext, dirPath) {
+    const fp = dirPath + "/" + name + "." + ext;
+    const { data, found } = readYmlFile(fp);
+    const res = { variables: { required: new Array(), optional: new Array() }, toolDoc: "" };
+    let tspec;
+    if (!found) {
+        throw new Error(`extractTaskToolDocAndVariables: file ${fp} not found`);
+    }
+    if (data.tool) {
+        data.tool.name = name;
+        tspec = data.tool;
+        res.toolDoc = JSON.stringify(tspec, null, "  ");
+    }
+    const { required, optional } = _parseTaskVariables(data);
+    res.variables.required = required;
+    res.variables.optional = optional;
+    return res;
+}
 function extractToolDoc(name, ext, dirPath) {
     let spec;
     let found = false;
@@ -97,4 +127,4 @@ function extractToolDoc(name, ext, dirPath) {
     }
     return { found: true, toolDoc: spec };
 }
-export { extractToolDoc, };
+export { extractToolDoc, extractTaskToolDocAndVariables, };

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

@@ -1,7 +1,6 @@
 import { InferenceStats } from "@locallm/types";
-declare function setOptions(args: Array<string> | undefined, options: Record<string, any>): Promise<Array<string>>;
 declare function readPromptFile(): string;
 declare function processOutput(res: any): Promise<void>;
 declare function parseInputOptions(options: any): Promise<string | null>;
 declare function formatStats(stats: InferenceStats): string;
-export { formatStats, parseInputOptions, processOutput, readPromptFile, setOptions };
+export { formatStats, parseInputOptions, processOutput, readPromptFile, };

package/dist/cmd/lib/utils.js

@@ -1,30 +1,8 @@
 import { marked } from "../../agent.js";
 import { formatMode, initFilepaths, inputMode, outputMode, promptfilePath } from "../../state/state.js";
-import { modes } from "../clicmds/modes.js";
 import { readClipboard, writeToClipboard } from "../sys/clipboard.js";
 import { readFile } from "../sys/read.js";
 import { splitThinking } from "../../utils/text.js";
-async function setOptions(args = [], options) {
-    for (const k of Object.keys(options)) {
-        let opt;
-        if (k.length == 1) {
-            opt = modes["-" + k.toLowerCase()];
-        }
-        else {
-            opt = modes["--" + k.toLowerCase()];
-        }
-        await opt.cmd([], undefined);
-    }
-    if (inputMode.value == "promptfile") {
-        const p = readPromptFile();
-        args.push(p);
-    }
-    else if (inputMode.value == "clipboard") {
-        const p = await readClipboard();
-        args.push(p);
-    }
-    return args;
-}
 function readPromptFile() {
     initFilepaths();
     return readFile(promptfilePath.value);
@@ -78,4 +56,4 @@ function formatStats(stats) {
     buf.push(`${stats.inferenceTimeSeconds}s inference)`);
     return buf.join(" ");
 }
-export { formatStats, parseInputOptions, processOutput, readPromptFile, setOptions };
+export { formatStats, parseInputOptions, processOutput, readPromptFile, };

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

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