@agent-smith/cli 0.0.37 → 0.0.39

package/dist/cmd/clicmds/cmds.js

@@ -9,6 +9,7 @@ import { executeJobCmd, readJob } from "../lib/execute_job.js";
 import { executeTaskCmd } from "../lib/execute_task.js";
 import { readCmds } from "../sys/read_cmds.js";
 import { readTask } from "../lib/utils.js";
+import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
 let cmds = {
     q: {
         cmd: async () => process.exit(0),
@@ -41,6 +42,11 @@ let cmds = {
         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",
+        args: "arguments: \n-workflow (required): the workflow name\n-args: arguments if any for the workflow"
+    },
     a: {
         cmd: executeActionCmd,
         description: "execute an action",
@@ -74,6 +80,11 @@ function initAliases() {
                     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),
+                    description: "wokflow: " + alias.name,
+                };
         }
     });
     return _cmds;
@@ -144,6 +155,15 @@ async function _executeJobCmd(args = [], options) {
     const res = await executeJobCmd(name, args, options);
     return res;
 }
+async function _executeWorkflowCmd(args = [], options) {
+    if (args.length == 0) {
+        console.warn("Provide a workflow name");
+        return;
+    }
+    const name = args.shift();
+    const res = await executeWorkflowCmd(name, args, options);
+    return res;
+}
 async function _readTaskCmd(args = [], options) {
     if (args.length == 0) {
         console.warn("Provide a task name");

package/dist/cmd/lib/execute_action.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, any, NodeReturnType<string | Record<string, any> | Array<any>>>;
-declare function executeActionCmd(args?: Array<string>, options?: any, quiet?: boolean): Promise<NodeReturnType<any>>;
+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>>;
 export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/execute_action.js

@@ -41,12 +41,28 @@ function pythonAction(path) {
     return action;
 }
 async function executeActionCmd(args = [], options = {}, quiet = false) {
-    const name = args.shift();
+    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 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);
@@ -69,7 +85,7 @@ async function executeActionCmd(args = [], options = {}, quiet = false) {
     if (input) {
         args.push(input);
     }
-    const res = await act.run(args, {});
+    const res = await act.run(args, options);
     if (res?.error) {
         throw res.error;
     }

package/dist/cmd/lib/execute_task.js

@@ -1,6 +1,6 @@
 import { brain, initAgent, taskBuilder } from "../../agent.js";
 import { getFeatureSpec } from "../../state/features.js";
-import { isChatMode, isDebug } from "../../state/state.js";
+import { isChatMode, isDebug, isVerbose } from "../../state/state.js";
 import { initTaskConf, initTaskParams, initTaskVars, parseInputOptions, readTask } from "./utils.js";
 async function executeTaskCmd(args = [], options = {}) {
     await initAgent();
@@ -8,10 +8,10 @@ async function executeTaskCmd(args = [], options = {}) {
         console.log("Task args:", args);
         console.log("Task options:", options);
     }
-    const isJob = !Array.isArray(args);
+    const isWorkflow = !Array.isArray(args);
     let name;
     let pr;
-    if (!isJob) {
+    if (!isWorkflow) {
         name = args.shift();
         const _pr = await parseInputOptions(options);
         if (!_pr) {
@@ -50,7 +50,7 @@ async function executeTaskCmd(args = [], options = {}) {
     const task = taskBuilder.fromYaml(res.ymlTask);
     let conf = {};
     let vars = {};
-    if (!isJob) {
+    if (!isWorkflow) {
         const tv = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
         conf = tv.conf;
         vars = tv.vars;
@@ -81,21 +81,23 @@ async function executeTaskCmd(args = [], options = {}) {
         process.stdout.write(t);
     });
     conf.expert = ex;
-    if (isDebug.value) {
+    if (isDebug.value || isVerbose.value) {
         conf.debug = true;
     }
-    const fres = await task.run({ prompt: pr, ...vars }, conf);
-    if (fres.error) {
-        throw new Error(`Error executing task: ${name} ${fres.data.error}`);
+    let ir;
+    try {
+        ir = await task.run({ prompt: pr, ...vars }, conf);
+    }
+    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: fres.text });
+        brain.ex.template.pushToHistory({ user: pr, assistant: ir.text });
     }
-    const ir = fres;
     if (isDebug.value) {
         console.log("\n", ir.stats);
     }

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

@@ -0,0 +1,3 @@
+import { NodeReturnType } from "../../../interfaces.js";
+declare function executeWorkflowCmd(name: string, args?: Array<any>, options?: any): Promise<NodeReturnType<any>>;
+export { executeWorkflowCmd, };

package/dist/cmd/lib/workflows/cmd.js

@@ -0,0 +1,52 @@
+import { isDebug, isVerbose } from "../../../state/state.js";
+import { readWorkflow } from "./read.js";
+import { executeTaskCmd } from "../execute_task.js";
+import { executeActionCmd } from "../execute_action.js";
+async function executeWorkflowCmd(name, args = [], options = {}) {
+    const { workflow, found } = await readWorkflow(name);
+    if (!found) {
+        throw new Error(`Workflow ${name} not found`);
+    }
+    const stepNames = Object.keys(workflow);
+    if (isDebug.value || isVerbose.value) {
+        console.log("Running workflow", name, stepNames.length, "steps");
+    }
+    let params = {};
+    let i = 0;
+    const finalTaskIndex = stepNames.length + 1;
+    let taskRes = { data: {}, error: new Error("Empty task res") };
+    for (const [name, step] of Object.entries(workflow)) {
+        if (isDebug.value || isVerbose.value) {
+            console.log(`${i + 1}: ${step.type} ${name}`);
+        }
+        const p = i == 0 ? [name, ...args] : { name: name, ...params };
+        switch (step.type) {
+            case "task":
+                try {
+                    taskRes = await executeTaskCmd(p, options);
+                }
+                catch (e) {
+                    throw new Error(`Wokflow task ${i + 1} error: ${e}`);
+                }
+                break;
+            case "action":
+                try {
+                    const ares = await executeActionCmd(p, options, true);
+                    taskRes = ares.data;
+                    if (i == finalTaskIndex) {
+                        console.log(taskRes.data);
+                    }
+                }
+                catch (e) {
+                    throw new Error(`Workflow action ${i + 1} error: ${e}`);
+                }
+                break;
+            default:
+                throw new Error(`Unknown task type ${step.type} in workflow ${name}`);
+        }
+        params = taskRes;
+        ++i;
+    }
+    return taskRes;
+}
+export { executeWorkflowCmd, };

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

@@ -0,0 +1,7 @@
+import { AgentTask } from "@agent-smith/jobs";
+import { FeatureType, NodeReturnType } from '../../../interfaces.js';
+declare function readWorkflow(name: string): Promise<{
+    found: boolean;
+    workflow: Record<string, AgentTask<FeatureType, any, NodeReturnType<any>, Record<string, any>>>;
+}>;
+export { readWorkflow, };

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

@@ -0,0 +1,104 @@
+import YAML from 'yaml';
+import { default as fs } from "fs";
+import { taskBuilder } from '../../../agent.js';
+import { getFeatureSpec } from '../../../state/features.js';
+import { createJsAction, readTask } from '../utils.js';
+import { pythonAction, systemAction } from './../execute_action.js';
+async function _createWorkflowFromSpec(spec) {
+    const steps = {};
+    for (const step of spec.steps) {
+        const type = Object.keys(step)[0];
+        const sval = step[type];
+        let name;
+        if (typeof sval == "string") {
+            name = sval;
+        }
+        else {
+            name = step[type].name;
+        }
+        if (type == "action") {
+            const { found, path, ext } = getFeatureSpec(name, "action");
+            if (!found) {
+                throw new Error(`Action ${name} not found`);
+            }
+            switch (ext) {
+                case "js":
+                    const { action } = await import(path);
+                    const at = action;
+                    at.type = "action";
+                    steps[name] = at;
+                    break;
+                case "mjs":
+                    const mjsa = await import(path);
+                    const act = createJsAction(mjsa.action);
+                    act.type = "action";
+                    steps[name] = act;
+                    break;
+                case "yml":
+                    const _t1 = systemAction(path);
+                    _t1.type = "action";
+                    steps[name] = _t1;
+                    break;
+                case "py":
+                    const _t = pythonAction(path);
+                    _t.type = "action";
+                    steps[name] = _t;
+                    break;
+                default:
+                    throw new Error(`Unknown feature extension ${ext}`);
+            }
+        }
+        else {
+            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(`Unable to read task ${name} ${path}`);
+            }
+            const tsk = taskBuilder.fromYaml(res.ymlTask, "task");
+            steps[name] = tsk;
+        }
+    }
+    return steps;
+}
+async function _readWorkflowFromDisk(name) {
+    const { found, path } = getFeatureSpec(name, "workflow");
+    if (!found) {
+        return { found: false, data: {} };
+    }
+    if (!fs.existsSync(path)) {
+        return { data: {}, found: false };
+    }
+    const file = fs.readFileSync(path, 'utf8');
+    const data = YAML.parse(file);
+    data.name = name;
+    return { data: data, found: true };
+}
+async function readWorkflow(name) {
+    const { found, ext } = getFeatureSpec(name, "workflow");
+    if (!found) {
+        return { found: false, workflow: {} };
+    }
+    let wf = {};
+    switch (ext) {
+        case "yml":
+            const { data } = await _readWorkflowFromDisk(name);
+            try {
+                const workflow = await _createWorkflowFromSpec(data);
+                if (!found) {
+                    return { found: false, workflow: {} };
+                }
+                wf = workflow;
+            }
+            catch (e) {
+                throw new Error(`Workflow create error: ${e}`);
+            }
+            break;
+        default:
+            throw new Error(`Workflow extension ${ext} not implemented`);
+    }
+    return { found: true, workflow: wf };
+}
+export { readWorkflow, };

package/dist/cmd/sys/read_features.js

@@ -21,6 +21,7 @@ function readFeaturesDir(dir) {
         job: [],
         action: [],
         cmd: [],
+        workflow: []
     };
     let dirpath = path.join(dir, "tasks");
     if (fs.existsSync(dirpath)) {
@@ -50,6 +51,20 @@ function readFeaturesDir(dir) {
             });
         });
     }
+    dirpath = path.join(dir, "workflows");
+    if (fs.existsSync(dirpath)) {
+        const data = _readDir(dirpath, [".yml"]);
+        data.forEach((filename) => {
+            const parts = filename.split(".");
+            const ext = parts.pop();
+            const name = parts.join("");
+            feats.workflow.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
     dirpath = path.join(dir, "actions");
     if (fs.existsSync(dirpath)) {
         const data = _readDir(dirpath, ["yml", ".js", "mjs", ".py"]);

package/dist/db/read.js

@@ -27,11 +27,12 @@ function _readFeaturesType(type) {
     return f;
 }
 function readFeatures() {
-    const feats = { task: {}, job: {}, action: {}, cmd: {} };
+    const feats = { task: {}, job: {}, action: {}, cmd: {}, workflow: {} };
     feats.task = _readFeaturesType("task");
     feats.job = _readFeaturesType("job");
     feats.action = _readFeaturesType("action");
     feats.cmd = _readFeaturesType("cmd");
+    feats.workflow = _readFeaturesType("workflow");
     return feats;
 }
 function readAliases() {

package/dist/db/schemas.js

@@ -24,6 +24,12 @@ const jobs = `CREATE TABLE IF NOT EXISTS job (
     path TEXT NOT NULL,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
+const workflow = `CREATE TABLE IF NOT EXISTS workflow (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml') )
+);`;
 const actions = `CREATE TABLE IF NOT EXISTS action (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
@@ -39,9 +45,9 @@ const cmds = `CREATE TABLE IF NOT EXISTS cmd (
 const aliases = `CREATE TABLE IF NOT EXISTS aliases (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
-    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'job') )
+    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'job', 'workflow') )
 );`;
 const schemas = [
-    filepaths, featurespaths, tasks, jobs, actions, cmds, plugins, aliases
+    filepaths, featurespaths, tasks, jobs, workflow, actions, cmds, plugins, aliases
 ];
 export { schemas };

package/dist/db/write.js

@@ -62,6 +62,9 @@ function updateAliases(feats) {
     feats.job.forEach((feat) => {
         existingAliases = _updateAlias(existingAliases, feat.name, "job");
     });
+    feats.workflow.forEach((feat) => {
+        existingAliases = _updateAlias(existingAliases, feat.name, "workflow");
+    });
 }
 function upsertAndCleanFeatures(feats, type) {
     const stmt = db.prepare(`SELECT name FROM ${type}`);
@@ -88,5 +91,6 @@ function updateFeatures(feats) {
     upsertAndCleanFeatures(feats.job, "job");
     upsertAndCleanFeatures(feats.action, "action");
     upsertAndCleanFeatures(feats.cmd, "cmd");
+    upsertAndCleanFeatures(feats.workflow, "workflow");
 }
 export { updatePromptfilePath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, };

package/dist/interfaces.d.ts

@@ -29,6 +29,11 @@ interface Features {
         path: string;
         ext: ActionExtension;
     }>;
+    workflow: Array<{
+        name: string;
+        path: string;
+        ext: WorkflowExtension;
+    }>;
 }
 interface ConfigFile {
     promptfile?: string;
@@ -44,11 +49,12 @@ type InputMode = "manual" | "promptfile" | "clipboard";
 type OutputMode = "txt" | "clipboard";
 type RunMode = "cli" | "cmd";
 type FormatMode = "text" | "markdown";
-type FeatureType = "task" | "job" | "action" | "cmd";
+type FeatureType = "task" | "job" | "action" | "cmd" | "workflow";
 type ActionExtension = "js" | "mjs" | "py" | "yml";
 type TaskExtension = "yml";
+type WorkflowExtension = "yml";
 type JobExtension = "yml";
 type CmdExtension = "js";
-type FeatureExtension = TaskExtension | JobExtension | CmdExtension | ActionExtension;
-type AliasType = "task" | "action" | "job";
-export { Cmd, CmdExecutor, NodeReturnType, InputMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, JobExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, };
+type FeatureExtension = TaskExtension | JobExtension | CmdExtension | ActionExtension | WorkflowExtension;
+type AliasType = "task" | "action" | "job" | "workflow";
+export { Cmd, CmdExecutor, NodeReturnType, InputMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, JobExtension, WorkflowExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, };

package/dist/main.d.ts

@@ -2,7 +2,8 @@ import { execute, run } from "./cmd/sys/execute.js";
 import { executeJobCmd } from "./cmd/lib/execute_job.js";
 import { executeActionCmd } from "./cmd/lib/execute_action.js";
 import { executeTaskCmd } from "./cmd/lib/execute_task.js";
+import { executeWorkflowCmd } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
 import { pingCmd } from "./cmd/clicmds/cmds.js";
 import { initAgent } from "./agent.js";
-export { execute, run, pingCmd, executeJobCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, };
+export { execute, run, pingCmd, executeJobCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, };

package/dist/main.js

@@ -2,7 +2,8 @@ import { execute, run } from "./cmd/sys/execute.js";
 import { executeJobCmd } from "./cmd/lib/execute_job.js";
 import { executeActionCmd } from "./cmd/lib/execute_action.js";
 import { executeTaskCmd } from "./cmd/lib/execute_task.js";
+import { executeWorkflowCmd } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
 import { pingCmd } from "./cmd/clicmds/cmds.js";
 import { initAgent } from "./agent.js";
-export { execute, run, pingCmd, executeJobCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, };
+export { execute, run, pingCmd, executeJobCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, };

package/dist/state/features.js

@@ -7,6 +7,7 @@ function readFeaturesDirs(featuresPaths) {
         job: [],
         action: [],
         cmd: [],
+        workflow: [],
     };
     featuresPaths.forEach((dir) => {
         const _f = readFeaturesDir(dir);
@@ -14,6 +15,7 @@ function readFeaturesDirs(featuresPaths) {
         _f.job.forEach((item) => feats.job.push(item));
         _f.action.forEach((item) => feats.action.push(item));
         _f.cmd.forEach((item) => feats.cmd.push(item));
+        _f.workflow.forEach((item) => feats.workflow.push(item));
     });
     return feats;
 }

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.37",
+  "version": "0.0.39",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc --noCheck",
@@ -17,7 +17,7 @@
     "@inquirer/prompts": "^7.3.3",
     "@inquirer/select": "^4.0.10",
     "@vue/reactivity": "^3.5.13",
-    "better-sqlite3": "^11.8.1",
+    "better-sqlite3": "^11.9.0",
     "clipboardy": "^4.0.0",
     "commander": "^13.1.0",
     "marked-terminal": "^7.3.0",
@@ -29,7 +29,7 @@
     "@agent-smith/tmem-jobs": "^0.0.4",
     "@commander-js/extra-typings": "^13.1.0",
     "@locallm/types": "^0.1.5",
-    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/better-sqlite3": "^7.6.12",
     "@types/marked-terminal": "^6.1.1",