@agent-smith/cli 0.0.102 → 0.0.104

package/dist/cmd/clicmds/aliases.js

@@ -2,9 +2,32 @@ import { allOptions } from "../options.js";
 import { executeTaskCmd } from "../lib/tasks/cmd.js";
 import { executeActionCmd } from "../lib/actions/cmd.js";
 import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
+import { executeAgentCmd } from "../lib/agents/cmd.js";
 function initCommandsFromAliases(program, aliases, features) {
     aliases.forEach((alias) => {
         switch (alias.type) {
+            case "agent":
+                const agcmd = program.command(`${alias.name} [prompt_and_vars...]`)
+                    .description("agent: " + alias.name)
+                    .action(async (...args) => {
+                    await executeAgentCmd(alias.name, args);
+                });
+                allOptions.forEach(o => agcmd.addOption(o));
+                if (features.agent[alias.name]?.variables) {
+                    const rtv = features.agent[alias.name].variables?.required;
+                    if (rtv) {
+                        for (const name of Object.keys(rtv)) {
+                            agcmd.option(`--${name} <value>`);
+                        }
+                    }
+                    const otv = features.agent[alias.name].variables?.optional;
+                    if (otv) {
+                        for (const name of Object.keys(otv)) {
+                            agcmd.option(`--${name} <value>`);
+                        }
+                    }
+                }
+                break;
             case "task":
                 const tcmd = program.command(`${alias.name} [prompt_and_vars...]`)
                     .description("task: " + alias.name)

package/dist/cmd/clicmds/cache.js

@@ -15,8 +15,8 @@ function createCacheFileContent(cmdFeats) {
         ++i;
     });
     const finalImports = imports.join("\n");
-    const cmds = `const cmds = [ ${cmdNames.join(", ")} ]`;
-    const end = "export { cmds }";
+    const cmds = `const cmds = [ ${cmdNames.join(", ")} ];\nconst isCacheReady = true;`;
+    const end = "export { isCacheReady, cmds }";
     return `${finalImports}\n\n${cmds}\n\n${end}`;
 }
 function ensureUserCmdsCacheFileExists(cacheFilePath) {

package/dist/cmd/clicmds/cmds.js

@@ -1,29 +1,24 @@
 import colors from "ansi-colors";
 import path from "path";
-import { pathToFileURL } from 'url';
 import YAML from 'yaml';
 import { cacheFilePath, dbPath } from "../../conf.js";
 import { readFeaturePaths, readFeaturesType, readTaskSetting } from "../../db/read.js";
 import { cleanupFeaturePaths, deleteTaskSetting, updateAliases, updateFeatures, upsertTaskSettings } from "../../db/write.js";
+import { isCacheReady, cmds } from "../../state/auto/usercmds.js";
 import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
 import { readPluginsPaths } from "../../state/plugins.js";
 import { runMode } from "../../state/state.js";
 import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from '../../state/tasks.js';
-import { cmds } from "../../state/auto/usercmds.js";
 import { deleteFileIfExists } from "../sys/delete_file.js";
 import { readCmd } from "../sys/read_cmds.js";
 import { readTask } from "../sys/read_task.js";
 import { updateUserCmdsCache } from './cache.js';
 async function initUserCmds(cmdFeats) {
     const features = Object.values(cmdFeats);
-    if (features.length == 0) {
-        return [];
-    }
     let endCmds = cmds;
-    if (cmds.length == 0) {
+    if (!isCacheReady) {
         updateUserCmdsCache(cacheFilePath, features);
-        const url = pathToFileURL(cacheFilePath).href;
-        const usrCmds = new Array();
+        const usrCmds = [];
         for (const feat of features) {
             const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
             const c = await readCmd(feat.name, cmdPath);

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

@@ -0,0 +1,3 @@
+import type { TaskOutput } from "@agent-smith/task";
+declare function executeAgentCmd(name: string, targs?: Array<any>): Promise<TaskOutput>;
+export { executeAgentCmd, };

package/dist/cmd/lib/agents/cmd.js

@@ -0,0 +1,10 @@
+import { parseCommandArgs } from "../options_parsers.js";
+import { getTaskPrompt } from "../tasks/utils.js";
+import { executeTask } from "../tasks/cmd.js";
+async function executeAgentCmd(name, targs = []) {
+    const ca = parseCommandArgs(targs);
+    const prompt = await getTaskPrompt(name, ca.args, ca.options);
+    ca.options.isAgent = true;
+    return await executeTask(name, { prompt: prompt }, ca.options);
+}
+export { executeAgentCmd, };

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

@@ -10,7 +10,7 @@ import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from "../.
 import { chat, program } from "../../cmds.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeError, runtimeWarning } from "../user_msgs.js";
-import { formatStats, processOutput } from "../utils.js";
+import { processOutput } from "../utils.js";
 import { readTask } from "./read.js";
 import { getTaskPrompt } from "./utils.js";
 async function executeTask(name, payload, options) {
@@ -86,17 +86,18 @@ async function executeTask(name, payload, options) {
         console.log("Task model:", model);
         console.log("Task vars:", vars);
     }
+    let emittedTokens = 0;
     const printToken = (t) => {
         if (options?.tokens === true) {
             let txt = t;
             txt = c ? t : `\x1b[100m${t}\x1b[0m`;
             process.stdout.write(txt);
-            ++i;
             c = !c;
         }
         else {
             process.stdout.write(t);
         }
+        ++emittedTokens;
     };
     let hasTools = false;
     if (task.def?.tools) {
@@ -113,12 +114,11 @@ async function executeTask(name, payload, options) {
         return `${ts} ${color.bold(i.toString())} ${te}`;
     };
     const perfTimer = usePerfTimer(false);
-    let i = 0;
     const processToken = (t) => {
-        if (i == 0) {
+        if (emittedTokens == 0) {
             perfTimer.start();
         }
-        spinner.text = formatTokenCount(i);
+        spinner.text = formatTokenCount(emittedTokens);
         if (!options?.verbose && !options?.debug) {
             if (hasThink && tpl) {
                 if (t == tpl.tags.think?.start) {
@@ -129,7 +129,7 @@ async function executeTask(name, payload, options) {
                 else if (t == tpl.tags.think?.end) {
                     continueWrite = true;
                     skipNextEmptyLinesToken = true;
-                    let msg = color.dim("Thinking:") + ` ${i} ${color.dim("tokens")}`;
+                    let msg = color.dim("Thinking:") + ` ${emittedTokens} ${color.dim("tokens")}`;
                     msg = msg + " " + color.dim(perfTimer.time());
                     spinner.info(msg);
                     return;
@@ -139,7 +139,7 @@ async function executeTask(name, payload, options) {
         else {
             if (tpl) {
                 if (t == tpl.tags.think?.end) {
-                    let msg = color.dim("Thinking:") + ` ${i} ${color.dim("tokens")}`;
+                    let msg = color.dim("Thinking:") + ` ${emittedTokens} ${color.dim("tokens")}`;
                     msg = msg + " " + color.dim(perfTimer.time());
                     console.log(msg);
                 }
@@ -165,17 +165,15 @@ async function executeTask(name, payload, options) {
             }
             printToken(t);
         }
-        ++i;
+        ++emittedTokens;
     };
-    const spinnerInit = (name) => ora(`Executing ${name} tool ...\n`);
-    let tcspinner;
     const onToolCall = (tc) => {
         console.log("⚒️ ", color.bold(name), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
-        tcspinner = spinnerInit(tc.name);
-        tcspinner.start();
     };
     const onToolCallEnd = (tr) => {
-        tcspinner.stop();
+        if (options?.debug) {
+            console.log(tr);
+        }
     };
     if (options?.onToken) {
         task.agent.lm.onToken = options.onToken;
@@ -250,7 +248,7 @@ async function executeTask(name, payload, options) {
     }
     if (options?.debug === true || options?.verbose === true) {
         try {
-            console.log("\n", formatStats(out.answer.stats));
+            console.log(emittedTokens.toString(), color.dim("tokens"), out.answer.stats.tokensPerSecond, color.dim("tps"));
             if (options?.debug === true) {
                 console.log(out.answer.stats);
             }
@@ -259,7 +257,7 @@ async function executeTask(name, payload, options) {
             runtimeWarning("Error formating stats:", `${e}`);
         }
     }
-    if (options?.backend) {
+    if (options?.backend || settings?.backend) {
         agent.lm = backend.value;
     }
     return out;

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

@@ -16,7 +16,7 @@ async function readTask(name, payload, options, agent) {
         console.log("Payload:", payload);
         console.log("Task options:", options);
     }
-    const { taskFileSpec, taskPath } = openTaskSpec(name);
+    const { taskFileSpec, taskPath } = openTaskSpec(name, options?.isAgent);
     const taskDir = path.dirname(taskPath);
     const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
     const conf = parseTaskConfigOptions(opts);
@@ -98,9 +98,19 @@ async function readTask(name, payload, options, agent) {
                             return res;
                         case "task":
                             options.isToolCall = true;
+                            options.isAgent = false;
                             const tres = await executeTask(toolName, params, options);
                             options.isToolCall = false;
                             return tres.answer.text;
+                        case "agent":
+                            options.isToolCall = true;
+                            options.isAgent = true;
+                            const agres = await executeTask(toolName, params, options);
+                            options.isToolCall = false;
+                            if (agres?.answer?.text) {
+                                return agres.answer.text;
+                            }
+                            return agres;
                         case "workflow":
                             const wres = await executeWorkflow(toolName, params, options);
                             return wres;

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

@@ -1,5 +1,5 @@
 import { LmTaskFileSpec } from "../../../interfaces.js";
-declare function openTaskSpec(name: string): {
+declare function openTaskSpec(name: string, isAgent?: boolean): {
     taskFileSpec: LmTaskFileSpec;
     taskPath: string;
 };

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

@@ -4,14 +4,15 @@ import { readTask } from "../../../cmd/sys/read_task.js";
 import { getFeatureSpec } from "../../../state/features.js";
 import { runtimeDataError } from '../user_msgs.js';
 import { readPromptFile } from '../utils.js';
-function openTaskSpec(name) {
-    const { found, path } = getFeatureSpec(name, "task");
+function openTaskSpec(name, isAgent = false) {
+    const ft = isAgent ? "agent" : "task";
+    const { found, path } = getFeatureSpec(name, ft);
     if (!found) {
-        throw new Error(`Task ${name} not found`);
+        throw new Error(`${ft} ${name} not found`);
     }
     const res = readTask(path);
     if (!res.found) {
-        throw new Error(`Task ${name}, ${path} not found`);
+        throw new Error(`${ft} ${name}, ${path} not found`);
     }
     const taskFileSpec = YAML.parse(res.ymlTask);
     taskFileSpec.name = name;

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

@@ -1,5 +1,3 @@
-import { InferenceStats } from "@locallm/types";
 declare function readPromptFile(): string;
 declare function processOutput(res: any): Promise<void>;
-declare function formatStats(stats: InferenceStats): string;
-export { formatStats, processOutput, readPromptFile, };
+export { processOutput, readPromptFile, };

package/dist/cmd/lib/utils.js

@@ -46,12 +46,4 @@ async function processOutput(res) {
         }
     }
 }
-function formatStats(stats) {
-    const buf = new Array();
-    buf.push(`${stats.tokensPerSecond} tps`);
-    buf.push(`- ${stats.totalTimeSeconds}s`);
-    buf.push(`(${stats.ingestionTimeSeconds}s ingestion /`);
-    buf.push(`${stats.inferenceTimeSeconds}s inference)`);
-    return buf.join(" ");
-}
-export { formatStats, processOutput, readPromptFile, };
+export { processOutput, readPromptFile, };

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

@@ -5,6 +5,9 @@ import { executeTask } from "../tasks/cmd.js";
 import { getTaskPrompt } from "../tasks/utils.js";
 import { readWorkflow } from "./read.js";
 import colors from "ansi-colors";
+import { getFeatureSpec } from "../../../state/features.js";
+import { pathToFileURL } from "node:url";
+import { runtimeError } from "../user_msgs.js";
 async function executeWorkflow(wname, args, options = {}) {
     const { workflow, found } = await readWorkflow(wname);
     if (!found) {
@@ -27,26 +30,46 @@ async function executeWorkflow(wname, args, options = {}) {
         switch (step.type) {
             case "task":
                 try {
-                    let pr = null;
+                    let tdata = taskRes;
                     if (i == 0) {
-                        pr = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
+                        tdata.prompt = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
                     }
                     else {
                         if (prevStepType) {
                             if (prevStepType == "task") {
-                                pr = taskRes.answer.text;
+                                tdata.prompt = taskRes.answer.text;
                             }
                         }
-                        if (!pr) {
-                            if (taskRes?.prompt) {
-                                pr = taskRes.prompt;
+                    }
+                    if (!tdata?.prompt) {
+                        throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
+                    }
+                    const tr = await executeTask(step.name, tdata, options);
+                    taskRes = { ...tr, ...taskRes };
+                }
+                catch (e) {
+                    throw new Error(`workflow task ${i + 1}: ${e}`);
+                }
+                break;
+            case "agent":
+                try {
+                    let tdata = taskRes;
+                    if (i == 0) {
+                        tdata.prompt = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
+                    }
+                    else {
+                        if (prevStepType) {
+                            if (prevStepType == "task") {
+                                tdata.prompt = taskRes.answer.text;
                             }
                         }
                     }
-                    if (!pr) {
+                    if (!tdata?.prompt) {
                         throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
                     }
-                    const tr = await executeTask(step.name, { prompt: pr }, options);
+                    options.isAgent = true;
+                    const tr = await executeTask(step.name, tdata, options);
+                    options.isAgent = false;
                     taskRes = { ...tr, ...taskRes };
                 }
                 catch (e) {
@@ -79,7 +102,7 @@ async function executeWorkflow(wname, args, options = {}) {
                         taskRes.args = adres;
                     }
                     else {
-                        taskRes = { ...adres, ...taskRes };
+                        taskRes = { ...adres };
                     }
                     if (i == finalTaskIndex) {
                         console.log(taskRes);
@@ -89,8 +112,32 @@ async function executeWorkflow(wname, args, options = {}) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
                 }
                 break;
+            case "cmd":
+                try {
+                    const { found, path } = getFeatureSpec(step.name, "cmd");
+                    if (!found) {
+                        throw new Error(`Command ${step.name} not found`);
+                    }
+                    const url = pathToFileURL(path).href;
+                    const jsa = await import(url);
+                    if (!jsa?.runCmd) {
+                        runtimeError(`workflow ${wname}: can not import the runCmd function from step ${i} for command ${step.name}: please add a runCmd function export`);
+                        return;
+                    }
+                    const cres = await jsa.runCmd(args, options);
+                    if (typeof cres == "string" || Array.isArray(cres)) {
+                        taskRes.args = cres;
+                    }
+                    else {
+                        taskRes = { ...cres, ...taskRes };
+                    }
+                }
+                catch (e) {
+                    throw new Error(`workflow command ${i + 1}: ${e}`);
+                }
+                break;
             default:
-                throw new Error(`unknown task type ${step.type} in workflow ${name}`);
+                throw new Error(`unknown workflow step type ${step.type} in workflow ${wname}`);
         }
         prevStepType = step.type;
         ++i;

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

@@ -1,104 +1,17 @@
-import { Agent } from '@agent-smith/agent';
-import { Task } from '@agent-smith/task';
 import { default as fs } from "fs";
 import YAML from 'yaml';
-import { backend } from '../../../state/backends.js';
 import { getFeatureSpec } from '../../../state/features.js';
-import { readTask } from "../../sys/read_task.js";
-import { pythonAction, systemAction } from '../actions/cmd.js';
-import { createJsAction } from '../actions/read.js';
-import { pathToFileURL } from 'url';
 async function _createWorkflowFromSpec(spec) {
     const steps = [];
-    let i = 1;
     for (const step of spec.steps) {
         const type = Object.keys(step)[0];
         const sval = step[type];
         const name = sval;
-        if (type == "action") {
-            const { found, path, ext } = getFeatureSpec(name, "action");
-            if (!found) {
-                throw new Error(`Action ${name} not found`);
-            }
-            switch (ext) {
-                case "js":
-                    const url = pathToFileURL(path).href;
-                    const { action } = await import(url);
-                    const at = action;
-                    const wf = {
-                        name: name,
-                        type: "action",
-                        run: at,
-                    };
-                    steps.push(wf);
-                    break;
-                case "mjs":
-                    const url2 = pathToFileURL(path).href;
-                    const mjsa = await import(url2);
-                    const act = createJsAction(mjsa.action);
-                    const wf2 = {
-                        name: name,
-                        type: "action",
-                        run: act,
-                    };
-                    steps.push(wf2);
-                    break;
-                case "yml":
-                    const _t1 = systemAction(path);
-                    const wf3 = {
-                        name: name,
-                        type: "action",
-                        run: _t1,
-                    };
-                    steps.push(wf3);
-                    break;
-                case "py":
-                    const _t = pythonAction(path);
-                    const wf4 = {
-                        name: name,
-                        type: "action",
-                        run: _t,
-                    };
-                    steps.push(wf4);
-                    break;
-                default:
-                    throw new Error(`Unknown feature extension ${ext}`);
-            }
-        }
-        else if (type == "adaptater") {
-            const { found, path } = getFeatureSpec(name, "adaptater");
-            if (!found) {
-                throw new Error(`Adaptater ${name} not found`);
-            }
-            const url = pathToFileURL(path).href;
-            const jsa = await import(url);
-            const act = createJsAction(jsa.action);
-            const wf = {
-                name: name,
-                type: "adaptater",
-                run: act,
-            };
-            steps.push(wf);
-        }
-        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 agent = new Agent(backend.value);
-            const tsk = Task.fromYaml(agent, res.ymlTask);
-            const wf = {
-                name: name,
-                type: "task",
-                run: tsk.run,
-            };
-            steps.push(wf);
-        }
-        ++i;
+        const wf = {
+            name: name,
+            type: type == "command" ? "cmd" : type,
+        };
+        steps.push(wf);
     }
     return steps;
 }

package/dist/cmd/sys/read_features.js

@@ -6,10 +6,8 @@ function _readDir(dir, ext) {
         const filepath = path.join(dir, filename);
         const isDir = fs.statSync(filepath).isDirectory();
         if (!isDir) {
-            for (let extension of ext) {
-                if (filename.endsWith(extension)) {
-                    fileNames.push(filename);
-                }
+            if (ext.includes(path.extname(filename))) {
+                fileNames.push(filename);
             }
         }
     });
@@ -22,6 +20,7 @@ function readFeaturesDir(dir) {
         cmd: [],
         workflow: [],
         adaptater: [],
+        agent: [],
     };
     let dirpath = path.join(dir, "tasks");
     if (fs.existsSync(dirpath)) {
@@ -37,6 +36,20 @@ function readFeaturesDir(dir) {
             });
         });
     }
+    dirpath = path.join(dir, "agents");
+    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.agent.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
     dirpath = path.join(dir, "workflows");
     if (fs.existsSync(dirpath)) {
         const data = _readDir(dirpath, [".yml"]);

package/dist/db/read.js

@@ -43,8 +43,9 @@ function readFeaturesType(type) {
 }
 function readFeatures() {
     const feats = {
-        task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}
+        task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}, agent: {}
     };
+    feats.agent = readFeaturesType("agent");
     feats.task = readFeaturesType("task");
     feats.action = readFeaturesType("action");
     feats.cmd = readFeaturesType("cmd");

package/dist/db/schemas.js

@@ -19,6 +19,13 @@ const tasks = `CREATE TABLE IF NOT EXISTS task (
     variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
+const agents = `CREATE TABLE IF NOT EXISTS agent (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    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,
@@ -51,12 +58,12 @@ const tool = `CREATE TABLE IF NOT EXISTS tool (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     spec TEXT NOT NULL,
-    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
+    type TEXT NOT NULL CHECK ( type IN ('agent', 'task', 'action', 'workflow') )
 );`;
 const alias = `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', 'workflow') )
+    type TEXT NOT NULL CHECK ( type IN ('agent', 'task', 'action', 'workflow') )
 );`;
 const backend = `CREATE TABLE IF NOT EXISTS backend (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -93,5 +100,6 @@ const schemas = [
     adaptater,
     backend,
     tasksSettings,
+    agents,
 ];
 export { schemas };

package/dist/db/write.js

@@ -96,6 +96,9 @@ function updateAliases(feats) {
     const deleteStmt = db.prepare("DELETE FROM aliases");
     deleteStmt.run();
     let existingAliases = new Array();
+    feats.agent.forEach((feat) => {
+        existingAliases = _updateAlias(existingAliases, feat.name, "agent");
+    });
     feats.task.forEach((feat) => {
         existingAliases = _updateAlias(existingAliases, feat.name, "task");
     });
@@ -158,6 +161,16 @@ function upsertTool(name, type, toolDoc) {
     }
 }
 function updateFeatures(feats) {
+    upsertAndCleanFeatures(feats.agent, "agent");
+    feats.agent.forEach((feat) => {
+        const { toolDoc, variables } = extractTaskToolDocAndVariables(feat.name, feat.ext, feat.path);
+        if (toolDoc.length > 0) {
+            upsertTool(feat.name, "agent", toolDoc);
+        }
+        if (Object.keys(variables.required).length > 0 || Object.keys(variables.optional).length > 0) {
+            updateVariables(feat.name, JSON.stringify(variables, null, "  "));
+        }
+    });
     upsertAndCleanFeatures(feats.task, "task");
     feats.task.forEach((feat) => {
         const { toolDoc, variables } = extractTaskToolDocAndVariables(feat.name, feat.ext, feat.path);

package/dist/index.js

@@ -4,6 +4,7 @@ import { query } from "./cli.js";
 import { buildCmds, parseCmd } from './cmd/cmds.js';
 import { formatMode, init, inputMode, isChatMode, outputMode, runMode } from './state/state.js';
 import { updateConfCmd } from './cmd/clicmds/updateconf.js';
+import { resetDbCmd } from './cmd/clicmds/cmds.js';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {
@@ -14,6 +15,10 @@ async function main() {
             await updateConfCmd(argv.slice(-1));
             return;
         }
+        else if (argv[2] == "reset") {
+            await resetDbCmd();
+            return;
+        }
     }
     await init();
     const program = await buildCmds();

package/dist/interfaces.d.ts

@@ -8,6 +8,11 @@ interface FeatureSpec {
     variables?: TaskVariables;
 }
 interface Features {
+    agent: Array<{
+        name: string;
+        path: string;
+        ext: AgentExtension;
+    }>;
     task: Array<{
         name: string;
         path: string;
@@ -100,7 +105,6 @@ interface FinalLmTaskConfig {
 interface WorkflowStep {
     name: string;
     type: string;
-    run: FeatureExecutor;
 }
 interface McpServerSpec {
     command: string;
@@ -136,14 +140,15 @@ type OutputMode = "txt" | "clipboard";
 type RunMode = "cli" | "cmd";
 type FormatMode = "text" | "markdown";
 type VerbosityMode = "quiet" | "verbose" | "debug";
-type FeatureType = "task" | "action" | "cmd" | "workflow" | "adaptater";
-type ToolType = "task" | "action" | "cmd" | "workflow";
+type FeatureType = "task" | "agent" | "action" | "cmd" | "workflow" | "adaptater";
+type ToolType = "task" | "agent" | "action" | "cmd" | "workflow";
 type ActionExtension = "js" | "mjs" | "py" | "yml";
 type TaskExtension = "yml";
+type AgentExtension = "yml";
 type AdaptaterExtension = "js";
 type WorkflowExtension = "yml";
 type CmdExtension = "js";
-type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension;
-type AliasType = "task" | "action" | "workflow";
+type FeatureExtension = TaskExtension | AgentExtension | CmdExtension | ActionExtension | WorkflowExtension;
+type AliasType = "task" | "agent" | "action" | "workflow";
 type FeatureExecutor<I = any, O = any> = (params: I, options: Record<string, any>) => Promise<O>;
-export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, TaskSettings, };
+export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, AgentExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, TaskSettings, };

package/dist/state/auto/usercmds.d.ts

@@ -1 +1,4 @@
-export const cmds: any[];
+import { Command } from "commander";
+declare const cmds: Command[];
+declare const isCacheReady = false;
+export { cmds, isCacheReady, };

package/dist/state/auto/usercmds.js

@@ -1,2 +1,3 @@
 const cmds = new Array();
-export { cmds };
+const isCacheReady = false;
+export { cmds, isCacheReady, };

package/dist/state/features.js

@@ -8,9 +8,11 @@ function readFeaturesDirs(featuresPaths) {
         cmd: [],
         workflow: [],
         adaptater: [],
+        agent: [],
     };
     featuresPaths.forEach((dir) => {
         const _f = readFeaturesDir(dir);
+        _f.agent.forEach((item) => feats.agent.push(item));
         _f.task.forEach((item) => feats.task.push(item));
         _f.action.forEach((item) => feats.action.push(item));
         _f.cmd.forEach((item) => feats.cmd.push(item));

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.102",
+  "version": "0.0.104",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -17,7 +17,7 @@
     "@inquirer/prompts": "^8.1.0",
     "@intrinsicai/gbnfgen": "0.12.0",
     "@locallm/api": "^0.7.3",
-    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "@vue/reactivity": "^3.5.26",
     "ansi-colors": "^4.1.3",
     "better-sqlite3": "^12.5.0",
@@ -40,7 +40,7 @@
     "@types/node": "^25.0.3",
     "openai": "^6.15.0",
     "restmix": "^0.6.1",
-    "rollup": "^4.54.0",
+    "rollup": "^4.55.1",
     "ts-node": "^10.9.2",
     "tslib": "2.8.1",
     "typescript": "^5.9.3"