@agent-smith/cli 0.0.39 → 0.0.41

package/dist/cmd/clicmds/cmds.js

@@ -1,17 +1,18 @@
-import { formatMode, isChatMode, isDebug, promptfile } from "../../state/state.js";
+import { formatMode, isChatMode, isDebug, promptfilePath, runMode } from "../../state/state.js";
 import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
 import { readAliases, readFeatures } from "../../db/read.js";
 import { cleanupFeaturePaths, updateAliases, updateFeatures, updatePromptfilePath } from "../../db/write.js";
 import { processConfPath } from "../../conf.js";
-import { executeActionCmd } from "../lib/execute_action.js";
+import { executeActionCmd } from "../lib/actions/cmd.js";
 import { initAgent, marked, taskBuilder } from "../../agent.js";
-import { executeJobCmd, readJob } from "../lib/execute_job.js";
-import { executeTaskCmd } from "../lib/execute_task.js";
+import { executeTaskCmd } from "../lib/tasks/cmd.js";
 import { readCmds } from "../sys/read_cmds.js";
-import { readTask } from "../lib/utils.js";
 import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
+import { readTask } from "../sys/read_task.js";
+import { deleteFileIfExists } from "../sys/reset.js";
+import { dbPath } from "../../db/db.js";
 let cmds = {
-    q: {
+    exit: {
         cmd: async () => process.exit(0),
         description: "exit the cli"
     },
@@ -28,20 +29,10 @@ let cmds = {
         description: "read a task",
         args: "arguments: \n-task (required): the task name"
     },
-    rj: {
-        cmd: _readJobCmd,
-        description: "read a job",
-        args: "arguments: \n-job (required): the job name"
-    },
     t: {
         cmd: _executeTaskCmd,
         description: "execute a task",
     },
-    j: {
-        cmd: _executeJobCmd,
-        description: "execute a job",
-        args: "arguments: \n-job (required): the job name\n-args: arguments if any for the job"
-    },
     w: {
         cmd: _executeWorkflowCmd,
         description: "execute a workflow",
@@ -57,6 +48,10 @@ let cmds = {
         description: "process config file",
         args: "arguments: \n-path (required): the path to the config.yml file"
     },
+    reset: {
+        cmd: _resetDbCmd,
+        description: "reset the config database",
+    },
 };
 function initAliases() {
     const aliases = readAliases();
@@ -75,11 +70,6 @@ function initAliases() {
                     description: "action: " + alias.name,
                 };
                 break;
-            case "job":
-                _cmds[alias.name] = {
-                    cmd: (args = [], options) => _executeJobCmd([alias.name, ...args], options),
-                    description: "job: " + alias.name,
-                };
             case "workflow":
                 _cmds[alias.name] = {
                     cmd: (args = [], options) => _executeWorkflowCmd([alias.name, ...args], options),
@@ -108,7 +98,7 @@ async function _updateConfCmd(args = [], options) {
     const { paths, pf } = await processConfPath(args[0]);
     if (pf.length > 0) {
         updatePromptfilePath(pf);
-        promptfile.value = pf;
+        promptfilePath.value = pf;
     }
     const feats = readFeaturesDirs(paths);
     updateFeatures(feats);
@@ -118,41 +108,29 @@ async function _updateConfCmd(args = [], options) {
         console.log("- [feature path]", el);
     }
 }
-async function _readJobCmd(args = [], options) {
-    if (args.length == 0) {
-        console.warn("Provide a job name");
+async function _resetDbCmd(args = [], options) {
+    if (runMode.value == "cli") {
+        console.log("This command can not be run in cli mode");
         return;
     }
-    const t = await readJob(args[0]);
-    console.log(t.data);
+    deleteFileIfExists(dbPath);
+    console.log("Config database reset ok. Run the conf command to recreate it");
 }
 async function _executeTaskCmd(args = [], options) {
     if (args.length == 0) {
         console.warn("Provide a task name");
         return;
     }
-    const { data, error } = await executeTaskCmd(args, options);
-    if (error) {
-        console.warn(error);
-    }
+    const res = await executeTaskCmd(args, options);
     if (formatMode.value == "markdown") {
         console.log("\n------------------\n");
-        console.log(marked.parse(data.text).trim());
+        console.log(marked.parse(res.answer.text).trim());
     }
     else {
         console.log();
     }
     if (isChatMode.value) {
     }
-    return data;
-}
-async function _executeJobCmd(args = [], options) {
-    if (args.length == 0) {
-        console.warn("Provide a job name");
-        return;
-    }
-    const name = args.shift();
-    const res = await executeJobCmd(name, args, options);
     return res;
 }
 async function _executeWorkflowCmd(args = [], options) {

package/dist/cmd/clicmds/modes.js

@@ -1,4 +1,4 @@
-import { formatMode, inputMode, isChatMode, isDebug, isVerbose, outputMode, runMode } from "../../state/state.js";
+import { formatMode, inputMode, isChatMode, isDebug, isShowTokens, isVerbose, outputMode, runMode } from "../../state/state.js";
 const modes = {
     "-d": {
         cmd: async () => {
@@ -9,20 +9,29 @@ const modes = {
         },
         description: "use debug mode",
     },
+    "-t": {
+        cmd: async () => {
+            isShowTokens.value = !isShowTokens.value;
+            if (runMode.value == "cli") {
+                console.log("Show tokens mode is", isShowTokens.value ? "on" : "off");
+            }
+        },
+        description: "use verbose mode",
+    },
     "-v": {
         cmd: async () => {
-            isVerbose.value = true;
+            isVerbose.value = !isVerbose.value;
             if (runMode.value == "cli") {
-                console.log("Verbose mode is on");
+                console.log("Verbose mode is", isVerbose.value ? "on" : "off");
             }
         },
         description: "use verbose mode",
     },
     "-c": {
         cmd: async () => {
-            isChatMode.value = true;
+            isChatMode.value = !isChatMode;
             if (runMode.value == "cli") {
-                console.log("Chat mode is on");
+                console.log("Chat mode is", isChatMode.value ? "on" : "off");
             }
         },
         description: "use chat mode for tasks",

package/dist/cmd/cmds.d.ts

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 declare function chat(): Promise<void>;
 declare function initCliCmds(): Promise<void>;
-declare function runCmd(cmdName: string, args?: Array<string>): Promise<void>;
+declare function runCmd(cmdName: string, args?: Array<string>, options?: any): Promise<void>;
 declare function buildCmds(): Promise<Command>;
 declare function parseCmd(): Promise<void>;
 export { buildCmds, chat, initCliCmds, parseCmd, runCmd };

package/dist/cmd/cmds.js

@@ -30,13 +30,13 @@ async function initCliCmds() {
     const _alias = initAliases();
     cliCmds = { ..._cmds, ..._alias };
 }
-async function runCmd(cmdName, args = []) {
+async function runCmd(cmdName, args = [], options = {}) {
     if (!(cmdName in cliCmds)) {
         console.log(`Command ${cmdName} not found`);
         return;
     }
     const cmd = cliCmds[cmdName].cmd;
-    await cmd(args, {});
+    await cmd(args, options);
     lastCmd.name = cmdName;
     lastCmd.args = args;
 }

package/dist/cmd/lib/{execute_action.d.ts → actions/cmd.d.ts}

@@ -1,6 +1,6 @@
 import { AgentTask } from "@agent-smith/jobs";
-import { FeatureType, NodeReturnType } from "../../interfaces.js";
-declare function systemAction(path: string): AgentTask<FeatureType, Array<string>, NodeReturnType<string>>;
-declare function pythonAction(path: string): AgentTask<FeatureType, Array<string>, NodeReturnType<string | Record<string, any> | Array<any>>>;
-declare function executeActionCmd(args?: Array<string> | Record<string, any>, options?: any, quiet?: boolean): Promise<NodeReturnType<any>>;
+import { FeatureType } from "../../../interfaces.js";
+declare function systemAction(path: string): AgentTask<FeatureType, Array<string>, any>;
+declare function pythonAction(path: string): AgentTask<FeatureType, Array<string>>;
+declare function executeActionCmd(args?: Array<string> | Record<string, any>, options?: any, quiet?: boolean): Promise<any>;
 export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/{execute_action.js → actions/cmd.js}

@@ -1,10 +1,11 @@
 import { useAgentTask } from "@agent-smith/jobs";
-import { getFeatureSpec } from '../../state/features.js';
-import { readYmlAction } from "../sys/read_yml_action.js";
-import { execute } from "../sys/execute.js";
-import { runPyScript } from "../sys/run_python.js";
-import { pyShell } from "../../state/state.js";
-import { createJsAction, parseInputOptions, processOutput } from "./utils.js";
+import { getFeatureSpec } from '../../../state/features.js';
+import { readYmlAction } from "../../sys/read_yml_action.js";
+import { execute } from "../../sys/execute.js";
+import { runPyScript } from "../../sys/run_python.js";
+import { pyShell } from "../../../state/state.js";
+import { processOutput } from "../utils.js";
+import { createJsAction } from "./read.js";
 function systemAction(path) {
     const action = useAgentTask({
         id: "system_action",
@@ -27,15 +28,17 @@ function pythonAction(path) {
         run: async (args) => {
             const { data, error } = await runPyScript(pyShell, "python3", path, args);
             if (error) {
-                return { data: {}, error: error };
+                throw new Error(`python error: ${error}`);
             }
             const txt = data.join("\n");
             let final = txt;
             if (txt.startsWith("{") || txt.startsWith("[")) {
-                final = JSON.parse(final);
+                try {
+                    final = JSON.parse(txt);
+                }
+                catch (e) { }
             }
-            const res = { data: final };
-            return res;
+            return final;
         }
     });
     return action;
@@ -58,17 +61,8 @@ async function executeActionCmd(args = [], options = {}, quiet = false) {
         throw new Error("Action not found");
     }
     let act;
-    if (!["js", "mjs"].includes(ext)) {
-        if (isWorkflow) {
-            throw new Error(`Action ${name} param error: ${typeof args}, ${args}`);
-        }
-    }
     switch (ext) {
         case "js":
-            const { action } = await import(path);
-            act = action;
-            break;
-        case "mjs":
             const mjsa = await import(path);
             act = createJsAction(mjsa.action);
             break;
@@ -81,18 +75,14 @@ async function executeActionCmd(args = [], options = {}, quiet = false) {
         default:
             throw new Error(`Action ext ${ext} not implemented`);
     }
-    const input = await parseInputOptions(options);
-    if (input) {
-        args.push(input);
-    }
     const res = await act.run(args, options);
     if (res?.error) {
         throw res.error;
     }
     if (!quiet) {
-        console.log(res.data);
+        console.log(res);
     }
     await processOutput(res);
-    return { data: res.data };
+    return res;
 }
 export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/actions/read.d.ts

@@ -0,0 +1,4 @@
+import { FeatureType } from "../../../interfaces.js";
+import { AgentTask } from "@agent-smith/jobs";
+declare function createJsAction(action: CallableFunction): AgentTask<FeatureType, any, any>;
+export { createJsAction };

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

@@ -0,0 +1,18 @@
+import { useAgentTask } from "@agent-smith/jobs";
+function createJsAction(action) {
+    const task = useAgentTask({
+        id: "",
+        title: "",
+        run: async (args) => {
+            try {
+                const res = await action(args);
+                return res;
+            }
+            catch (e) {
+                throw new Error(`executing action:${e}`);
+            }
+        }
+    });
+    return task;
+}
+export { createJsAction };

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

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

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

@@ -0,0 +1,37 @@
+import { getFeatureSpec } from "../../../state/features.js";
+import { processOutput } from "../utils.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;
+    }
+    const { found, path } = getFeatureSpec(name, "adaptater");
+    if (!found) {
+        throw new Error(`adaptater ${name} not found`);
+    }
+    let act;
+    const jsa = await import(path);
+    act = createJsAction(jsa.action);
+    let res;
+    try {
+        res = await act.run(args, options);
+    }
+    catch (e) {
+        throw new Error(`adaptater ${name}: ${e}`);
+    }
+    if (res?.error) {
+        throw res.error;
+    }
+    await processOutput(res);
+    return res;
+}
+export { executeAdaptaterCmd, };

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

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

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

@@ -0,0 +1,144 @@
+import { brain, initAgent, taskBuilder } from "../../../agent.js";
+import { getFeatureSpec } from "../../../state/features.js";
+import { isChatMode, isDebug, isShowTokens, isVerbose } from "../../../state/state.js";
+import { initTaskConf, initTaskParams, initTaskVars, parseInputOptions } from "../utils.js";
+import { readTask } from "../../sys/read_task.js";
+import { readTool } from "../../../db/read.js";
+import { executeActionCmd, } from "../actions/cmd.js";
+import { executeWorkflowCmd } from "../workflows/cmd.js";
+async function executeTaskCmd(args = [], options = {}) {
+    await initAgent();
+    if (isDebug.value) {
+        console.log("Task args:", args);
+        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;
+        delete args.name;
+        pr = args.prompt;
+        delete args.prompt;
+    }
+    const { found, path } = getFeatureSpec(name, "task");
+    if (!found) {
+        throw new Error(`Task ${name} not found`);
+    }
+    const res = readTask(path);
+    if (!res.found) {
+        throw new Error(`Task ${name}, ${path} not found`);
+    }
+    const taskSpec = taskBuilder.readFromYaml(res.ymlTask);
+    if (taskSpec.toolsList) {
+        taskSpec.tools = [];
+        for (const toolName of taskSpec.toolsList) {
+            const { found, tool, type } = readTool(toolName);
+            const lmTool = {
+                ...tool,
+                execute: async (name, args) => {
+                    switch (type) {
+                        case "action":
+                            const res = await executeActionCmd([name, ...Object.values(args)], options, true);
+                            return res;
+                        case "task":
+                            const tres = await executeTaskCmd([name, args], options);
+                            return tres;
+                        case "workflow":
+                            const wres = await executeWorkflowCmd(name, ...Object.values(args), options);
+                            return wres;
+                        default:
+                            throw new Error(`unknown tool execution function type: ${type}`);
+                    }
+                }
+            };
+            if (!found) {
+                console.warn(`Problem: tool ${toolName} not found for task ${taskSpec.name}`);
+                continue;
+            }
+            taskSpec.tools.push(lmTool);
+        }
+        delete taskSpec.toolsList;
+    }
+    ;
+    const task = taskBuilder.init(taskSpec);
+    let conf = {};
+    let vars = {};
+    if (!isWorkflow) {
+        const tv = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
+        conf = tv.conf;
+        vars = tv.vars;
+    }
+    else {
+        const tv = initTaskParams({ name: name, prompt: pr, ...args }, taskSpec?.inferParams ? taskSpec.inferParams : {});
+        conf = tv.conf;
+        vars = tv.vars;
+    }
+    conf = initTaskConf(conf, taskSpec);
+    if (isDebug.value) {
+        console.log("Task conf:", conf);
+        console.log("Task vars:", vars);
+    }
+    const ex = brain.getOrCreateExpertForModel(conf.model.name, conf.model.template);
+    if (!ex) {
+        throw new Error("No expert found for model " + conf.model.name);
+    }
+    ex.checkStatus();
+    let i = 0;
+    let c = false;
+    ex.backend.setOnToken((t) => {
+        let txt = t;
+        if (isShowTokens.value) {
+            txt = c ? t : `\x1b[100m${t}\x1b[0m`;
+        }
+        process.stdout.write(txt);
+        ++i;
+        c = !c;
+    });
+    conf.expert = ex;
+    if (isDebug.value || isVerbose.value) {
+        conf.debug = true;
+    }
+    let out;
+    try {
+        out = await task.run({ prompt: pr, ...vars }, conf);
+        console.log();
+    }
+    catch (err) {
+        throw new Error(`Error executing task: ${name} ${err}`);
+    }
+    conf.prompt = pr;
+    if (isChatMode.value) {
+        if (brain.ex.name != ex.name) {
+            brain.setDefaultExpert(ex);
+        }
+        brain.ex.template.pushToHistory({ user: pr, assistant: out.answer.text });
+    }
+    if (isDebug.value) {
+        console.log("\n", out.answer.stats);
+    }
+    return out;
+}
+export { executeTaskCmd };

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

@@ -0,0 +1,6 @@
+import { FeatureExtension } from '../../interfaces.js';
+declare function extractToolDoc(name: string, ext: FeatureExtension, dirPath: string): {
+    found: boolean;
+    toolDoc: string;
+};
+export { extractToolDoc, };

package/dist/cmd/lib/tools.js

@@ -0,0 +1,76 @@
+import YAML from 'yaml';
+import * as fs from 'fs';
+function _extractToolDoc(filePath, startComment, endComment) {
+    try {
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        const startMarker = startComment + '\n# tool';
+        if (!fileContent.startsWith(startMarker)) {
+            return { found: false, doc: "" };
+        }
+        const endMarker = endComment;
+        const startIndex = fileContent.indexOf(startMarker) + startMarker.length;
+        const endIndex = fileContent.indexOf(endMarker, startIndex);
+        if (endIndex === -1) {
+            throw new Error(`Markers not found in the file: ${filePath}`);
+        }
+        const extractedContent = fileContent.substring(startIndex, endIndex).trim();
+        return { found: true, doc: extractedContent };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('ENOENT')) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            else {
+                throw new Error(`Error processing the file: ${filePath}. ${error.message}`);
+            }
+        }
+        else {
+            throw new Error(`An unexpected error occurred: ${error}`);
+        }
+    }
+}
+function _extractPyToolDoc(filePath) {
+    return _extractToolDoc(filePath, '"""', '"""');
+}
+function _extractJsToolDoc(filePath) {
+    return _extractToolDoc(filePath, '/*', '*/');
+}
+function _parseToolDoc(rawTxt, name) {
+    try {
+        const res = YAML.parse(rawTxt);
+        res["name"] = name;
+        return res;
+    }
+    catch (e) {
+        throw new Error(`Error parsing tool ${name}: data:\n${rawTxt}\n`);
+    }
+}
+function extractToolDoc(name, ext, dirPath) {
+    let spec;
+    let found = false;
+    let doc;
+    switch (ext) {
+        case "py":
+            let res = _extractPyToolDoc(dirPath + "/" + name + "." + ext);
+            found = res.found;
+            doc = res.doc;
+            break;
+        case "js":
+            let res2 = _extractJsToolDoc(dirPath + "/" + name + "." + ext);
+            found = res2.found;
+            doc = res2.doc;
+            break;
+        default:
+            return { found: false, toolDoc: "" };
+    }
+    if (found) {
+        const ts = _parseToolDoc(doc, name);
+        spec = JSON.stringify(ts, null, "  ");
+    }
+    else {
+        return { found: false, toolDoc: "" };
+    }
+    return { found: true, toolDoc: spec };
+}
+export { extractToolDoc, };

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

@@ -1,14 +1,7 @@
-import { AgentTask } from "@agent-smith/jobs";
-import { LmTask } from "@agent-smith/lmtask";
-import { FeatureType, NodeReturnType } from "../../interfaces.js";
+import { LmTask } from "../../../../lmtask/dist/interfaces.js";
 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 readTask(taskpath: string): {
-    found: boolean;
-    ymlTask: string;
-};
-declare function readTasksDir(dir: string): Array<string>;
 declare function initTaskConf(conf: Record<string, any>, taskSpec: LmTask): Record<string, any>;
 declare function initTaskParams(params: Record<string, any>, inferParams: Record<string, any>): {
     conf: Record<string, any>;
@@ -20,5 +13,4 @@ declare function initTaskVars(args: Array<any>, inferParams: Record<string, any>
     vars: Record<string, any>;
 };
 declare function parseInputOptions(options: any): Promise<string | null>;
-declare function createJsAction(action: CallableFunction): AgentTask<FeatureType, any, NodeReturnType<any>>;
-export { createJsAction, initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, readTask, readTasksDir, setOptions };
+export { initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, setOptions };