@agent-smith/cli 0.0.36 → 0.0.38

package/dist/cmd/clicmds/cmds.js

@@ -1,4 +1,4 @@
-import { formatMode, isChatMode, promptfile } from "../../state/state.js";
+import { formatMode, isChatMode, isDebug, promptfile } 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";
@@ -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;
@@ -86,7 +97,7 @@ async function initCmds() {
     return cmds;
 }
 async function pingCmd(args = [], options) {
-    const isUp = await initAgent(true);
+    const isUp = await initAgent(isDebug.value);
     return isUp;
 }
 async function _updateConfCmd(args = [], options) {
@@ -120,13 +131,13 @@ async function _executeTaskCmd(args = [], options) {
         console.warn("Provide a task name");
         return;
     }
-    const { ok, data, conf, error } = await executeTaskCmd(args, options);
-    if (!ok) {
+    const { data, error } = await executeTaskCmd(args, options);
+    if (error) {
         console.warn(error);
     }
     if (formatMode.value == "markdown") {
         console.log("\n------------------\n");
-        console.log(marked.parse(data).trim());
+        console.log(marked.parse(data.text).trim());
     }
     else {
         console.log();
@@ -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 } from "../../interfaces.js";
-declare function systemAction(path: string): AgentTask<FeatureType>;
-declare function pythonAction(path: string): AgentTask<FeatureType>;
-declare function executeActionCmd(args?: Array<string>, options?: any, quiet?: boolean): Promise<any>;
+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>>;
 export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/execute_action.js

@@ -15,7 +15,7 @@ function systemAction(path) {
                 actionSpec.data.args = [];
             }
             const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...args]);
-            return { data: out.trim(), error: "", ok: true };
+            return { data: out.trim() };
         }
     });
     return action;
@@ -25,24 +25,44 @@ function pythonAction(path) {
         id: "python_action",
         title: "",
         run: async (args) => {
-            const out = await runPyScript(pyShell, "python3", path, args);
-            const txt = out.join("\n");
-            let data = txt;
+            const { data, error } = await runPyScript(pyShell, "python3", path, args);
+            if (error) {
+                return { data: {}, error: error };
+            }
+            const txt = data.join("\n");
+            let final = txt;
             if (txt.startsWith("{") || txt.startsWith("[")) {
-                data = JSON.parse(data);
+                final = JSON.parse(final);
             }
-            return { data: data, error: "", ok: true };
+            const res = { data: final };
+            return res;
         }
     });
     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) {
-        return { ok: false, data: {}, error: "Action not 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);
@@ -65,11 +85,14 @@ 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;
+    }
     if (!quiet) {
         console.log(res.data);
     }
     await processOutput(res);
-    return { ok: true, data: res.data, error: "" };
+    return { data: res.data };
 }
 export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/execute_job.js

@@ -12,8 +12,7 @@ async function executeJobCmd(name, args = [], options = {}) {
         console.log("Running job", name, Object.keys(job.tasks).length, "tasks");
     }
     if (!found) {
-        console.log(`Job ${name} not found`);
-        return { error: `Job ${name} not found` };
+        throw new Error(`Job ${name} not found`);
     }
     await job.start();
     let res = {};
@@ -26,7 +25,7 @@ async function executeJobCmd(name, args = [], options = {}) {
             const chain = task.properties?.chain;
             const { found, path } = getFeatureSpec(name, "task");
             if (!found) {
-                return { ok: false, data: {}, error: `Task ${name} not found` };
+                throw new Error(`Task ${name} not found`);
             }
             const tres = readTask(path);
             if (!tres.found) {
@@ -154,6 +153,9 @@ async function executeJobCmd(name, args = [], options = {}) {
                 }
                 try {
                     res = await job.runTask(name, _p, options);
+                    if (res?.error) {
+                        throw new Error(`Error executing job action ${res.error}`);
+                    }
                 }
                 catch (e) {
                     throw new Error(`Error executing job action ${e}`);
@@ -170,7 +172,7 @@ async function executeJobCmd(name, args = [], options = {}) {
                 params = { ...res.data, ...nextParams };
             }
             catch (err) {
-                return { error: `Error executing (${task.type}) task ${name}: ${err}` };
+                throw new Error(`Error executing (${task.type}) task ${name}: ${err}`);
             }
         }
         ++i;
@@ -248,7 +250,8 @@ async function _createJobFromSpec(spec) {
             if (t?.chain) {
                 at.properties = { "chain": true };
             }
-            tasks[t.name] = at;
+            const tsk = at;
+            tasks[t.name] = tsk;
         }
     }
     job.tasks = tasks;

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

@@ -1,2 +1,4 @@
-declare function executeTaskCmd(args?: Array<string> | Record<string, any>, options?: any): Promise<any>;
+import { NodeReturnType } from "../../interfaces.js";
+import { InferenceResult } from "@locallm/types/dist/interfaces.js";
+declare function executeTaskCmd(args?: Array<string> | Record<string, any>, options?: any): Promise<NodeReturnType<InferenceResult>>;
 export { executeTaskCmd };

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) {
@@ -37,11 +37,10 @@ async function executeTaskCmd(args = [], options = {}) {
         name = args.name;
         delete args.name;
         pr = args.prompt;
-        delete args.prompt;
     }
     const { found, path } = getFeatureSpec(name, "task");
     if (!found) {
-        return { ok: false, data: "", conf: {}, error: `Task ${name} not found` };
+        return { data: {}, error: new Error(`Task ${name} not found`) };
     }
     const res = readTask(path);
     if (!res.found) {
@@ -51,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;
@@ -82,20 +81,26 @@ async function executeTaskCmd(args = [], options = {}) {
         process.stdout.write(t);
     });
     conf.expert = ex;
-    if (isDebug.value) {
+    if (isDebug.value || isVerbose.value) {
         conf.debug = true;
     }
-    const data = await task.run({ prompt: pr, ...vars }, conf);
-    if (data?.error) {
-        return { ok: false, data: "", conf: conf, error: `Error executing task: ${name} ${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: data.text });
+        brain.ex.template.pushToHistory({ user: pr, assistant: ir.text });
+    }
+    if (isDebug.value) {
+        console.log("\n", ir.stats);
     }
-    return { ok: true, data: data.text, conf: conf, error: "" };
+    return { data: ir };
 }
 export { executeTaskCmd };

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

@@ -1,6 +1,6 @@
-import { AgentTask } from "@agent-smith/jobs/dist/jobsinterfaces.js";
+import { AgentTask } from "@agent-smith/jobs";
 import { LmTask } from "@agent-smith/lmtask";
-import { FeatureType } from "../../interfaces.js";
+import { FeatureType, NodeReturnType } from "../../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>;
@@ -20,5 +20,5 @@ 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>;
+declare function createJsAction(action: CallableFunction): AgentTask<FeatureType, any, NodeReturnType<any>>;
 export { createJsAction, initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, readTask, readTasksDir, setOptions };

package/dist/cmd/lib/utils.js

@@ -44,7 +44,6 @@ async function processOutput(res) {
         let hasOutput = false;
         if (res?.data) {
             data = res.data;
-            0;
             hasOutput = true;
         }
         if (res?.text) {
@@ -129,7 +128,7 @@ function initTaskConf(conf, taskSpec) {
 function initTaskParams(params, inferParams) {
     const conf = { inferParams: inferParams };
     if (!params?.prompt) {
-        throw new Error(`Error initializing task variable: provide a prompt`);
+        throw new Error(`Error initializing task params: provide a prompt`);
     }
     if (params?.images) {
         conf.inferParams.images = params.images;
@@ -236,8 +235,14 @@ function createJsAction(action) {
         id: "",
         title: "",
         run: async (args) => {
-            const res = await action(args);
-            return { ok: true, data: res };
+            try {
+                const res = await action(args);
+                return { ok: true, data: res };
+            }
+            catch (e) {
+                const err = new Error(`Error executing action ${e}`);
+                return { ok: false, data: {}, error: err };
+            }
         }
     });
     return task;

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,51 @@
+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 ${i + 1} error: ${e}`);
+                }
+                break;
+            case "action":
+                try {
+                    taskRes = await executeActionCmd(p, options, true);
+                    if (i == finalTaskIndex) {
+                        console.log(taskRes.data);
+                    }
+                }
+                catch (e) {
+                    throw new Error(`Wokflow ${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/cmd/sys/run_python.d.ts

@@ -1,3 +1,4 @@
+import { NodeReturnType } from '../../interfaces.js';
 import { PythonShell } from 'python-shell';
-declare function runPyScript(rsShell: PythonShell, pythonPath: string, scriptPath: string, scriptArgs: Array<string>, handleOutputFrom?: "msg" | "stderr", onEmitLine?: CallableFunction): Promise<string[]>;
+declare function runPyScript(rsShell: PythonShell, pythonPath: string, scriptPath: string, scriptArgs: Array<string>, onEmitLine?: CallableFunction): Promise<NodeReturnType<Array<string>>>;
 export { runPyScript };

package/dist/cmd/sys/run_python.js

@@ -1,5 +1,5 @@
 import { PythonShell } from 'python-shell';
-async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, handleOutputFrom = "msg", onEmitLine) {
+async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, onEmitLine) {
     const _options = {
         mode: "text",
         pythonPath: pythonPath,
@@ -9,35 +9,24 @@ async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, handleOu
     let promiseResolve;
     let promise = new Promise((resolve) => promiseResolve = resolve);
     rsShell = new PythonShell(scriptPath, _options);
-    const msgs = new Array();
+    const res = { data: new Array() };
     function handleLine(msg) {
         if (onEmitLine) {
             onEmitLine(msg);
         }
-        msgs.push(msg);
+        res.data.push(msg);
     }
     rsShell.on('message', function (message) {
-        if (handleOutputFrom == "msg") {
-            handleLine(message);
-        }
-    });
-    rsShell.on('stderr', function (err) {
-        console.log("STDERR", err);
-        if (handleOutputFrom == "stderr") {
-            handleLine(err);
-        }
-        else {
-            promiseResolve(true);
-        }
+        handleLine(message);
     });
     rsShell.on('pythonError', function (err) {
         console.log("PYERR", `${err.message}, ${err.traceback}`);
-        promiseResolve(true);
+        res.error = new Error(err.traceback.toString());
     });
     rsShell.end(function (err, code, signal) {
         promiseResolve(true);
     });
     await promise;
-    return msgs;
+    return res;
 }
 export { runPyScript };

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,22 +29,32 @@ interface Features {
         path: string;
         ext: ActionExtension;
     }>;
+    workflow: Array<{
+        name: string;
+        path: string;
+        ext: WorkflowExtension;
+    }>;
 }
 interface ConfigFile {
     promptfile?: string;
     features?: Array<string>;
     plugins?: Array<string>;
 }
+interface NodeReturnType<T = Record<string, any>> {
+    data: T;
+    error?: Error;
+}
 type CmdExecutor = (args: Array<string>, options: any) => Promise<any>;
 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, 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.36",
+  "version": "0.0.38",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc --noCheck",
@@ -11,17 +11,17 @@
   },
   "dependencies": {
     "@agent-smith/brain": "^0.0.38",
-    "@agent-smith/jobs": "^0.0.12",
-    "@agent-smith/lmtask": "^0.0.30",
+    "@agent-smith/jobs": "^0.0.13",
+    "@agent-smith/lmtask": "^0.0.31",
     "@agent-smith/tfm": "^0.1.1",
     "@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",
-    "modprompt": "^0.10.3",
+    "modprompt": "^0.10.4",
     "python-shell": "^5.0.0",
     "yaml": "^2.7.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",