@agent-smith/cli 0.0.95 → 0.0.97

package/dist/cli.js

@@ -7,7 +7,7 @@ async function query(program) {
     const args = q.split(" ");
     await program.parseAsync(args, { from: "user" });
     if (isChatMode.value) {
-        await chat(program);
+        await chat(program, {});
     }
     await query(program);
 }

package/dist/cmd/clicmds/base.js

@@ -1,38 +1,28 @@
-import YAML from 'yaml';
-import { dbPath } from "../../conf.js";
-import { readFeaturePaths, readFeaturesType } from "../../db/read.js";
-import { cleanupFeaturePaths, updateAliases, updateFeatures } from "../../db/write.js";
-import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
-import { readPluginsPaths } from "../../state/plugins.js";
-import { runMode } from "../../state/state.js";
-import { showModelsCmd } from "../lib/models.js";
+import { Option } from "commander";
+import { listBackends, setBackend } from "../../state/backends.js";
 import { parseCommandArgs } from "../lib/options_parsers.js";
-import { deleteFileIfExists } from "../sys/delete_file.js";
-import { readTask } from "../sys/read_task.js";
+import { processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd } from "./cmds.js";
 import { updateConfCmd } from "./update.js";
-import { listBackends, setBackend } from "../../state/backends.js";
+import { inferenceOptions } from "../options.js";
 function initBaseCommands(program) {
     program.command("exit")
         .description("exit the cli")
         .action(() => process.exit(0));
-    program.command("tasks")
+    const tasksCmd = program.command("tasks")
         .description("list all the tasks")
         .action(async (...args) => {
-        const ts = Object.keys(readFeaturesType("task")).sort();
-        console.table(ts);
-    });
-    program.command("task <task>")
-        .description("read a task")
-        .action(async (...args) => {
         const ca = parseCommandArgs(args);
-        await _readTaskCmd(ca.args);
+        await processTasksCmd(ca.args, ca.options);
     });
-    program.command("models [filters...]")
-        .description("list the available models")
+    tasksCmd.addOption(new Option("-c, --conf", "output the tasks config"));
+    const taskCmd = program.command("task <task>")
+        .description("read a task")
         .action(async (...args) => {
         const ca = parseCommandArgs(args);
-        await showModelsCmd(ca.args);
+        await processTaskCmd(ca.args, ca.options);
     });
+    inferenceOptions.forEach(o => taskCmd.addOption(o));
+    taskCmd.addOption(new Option("--reset", "reset the task config to the original"));
     program.command("backend <name>")
         .description("set the default backend")
         .action(async (...args) => {
@@ -47,7 +37,7 @@ function initBaseCommands(program) {
     program.command("update")
         .description("update the available features: run this after adding a new feature")
         .action(async (...args) => {
-        await _updateFeatures();
+        await updateFeaturesCmd();
     });
     program.command("conf <path>")
         .description("process config file")
@@ -58,44 +48,8 @@ function initBaseCommands(program) {
     program.command("reset")
         .description("reset the config database")
         .action(async (...args) => {
-        await _resetDbCmd();
+        await resetDbCmd();
     });
     return program;
 }
-async function _resetDbCmd() {
-    if (runMode.value == "cli") {
-        console.log("This command can not be run in cli mode");
-        return;
-    }
-    deleteFileIfExists(dbPath);
-    console.log("Config database reset ok. Run the conf command to recreate it");
-}
-async function _updateFeatures() {
-    const fp = readFeaturePaths();
-    const pp = await readPluginsPaths();
-    const paths = [...fp, ...pp];
-    const feats = readFeaturesDirs(paths);
-    updateFeatures(feats);
-    updateAliases(feats);
-    const deleted = cleanupFeaturePaths(paths);
-    for (const el of deleted) {
-        console.log("- [feature path]", el);
-    }
-}
-async function _readTaskCmd(args) {
-    if (args.length == 0) {
-        console.warn("Provide a task name");
-        return;
-    }
-    const { found, path } = getFeatureSpec(args[0], "task");
-    if (!found) {
-        console.warn(`FeatureType ${args[0]} not found`);
-        return;
-    }
-    const res = readTask(path);
-    if (!res.found) {
-        throw new Error(`Task ${args[0]}, ${path} not found`);
-    }
-    console.log(YAML.stringify(res.ymlTask));
-}
 export { initBaseCommands };

package/dist/cmd/clicmds/cmds.d.ts

@@ -1,4 +1,8 @@
 import { Command } from 'commander';
 import { FeatureSpec } from '../../interfaces.js';
 declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>): Promise<Array<Command>>;
-export { initUserCmds };
+declare function resetDbCmd(): Promise<any>;
+declare function updateFeaturesCmd(): Promise<any>;
+declare function processTasksCmd(args: Array<string>, options: Record<string, any>): Promise<void>;
+declare function processTaskCmd(args: Array<string>, options: Record<string, any>): Promise<any>;
+export { initUserCmds, resetDbCmd, updateFeaturesCmd, processTaskCmd, processTasksCmd, };

package/dist/cmd/clicmds/cmds.js

@@ -1,4 +1,15 @@
 import { readCmds } from "../sys/read_cmds.js";
+import YAML from 'yaml';
+import colors from "ansi-colors";
+import { dbPath } from "../../conf.js";
+import { readFeaturePaths, readFeaturesType, readTaskSetting } from "../../db/read.js";
+import { cleanupFeaturePaths, deleteTaskSetting, updateAliases, updateFeatures, upsertTaskSettings } from "../../db/write.js";
+import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
+import { readPluginsPaths } from "../../state/plugins.js";
+import { runMode } from "../../state/state.js";
+import { deleteFileIfExists } from "../sys/delete_file.js";
+import { readTask } from "../sys/read_task.js";
+import { isTaskSettingsInitialized, initTaskSettings, tasksSettings } from '../../state/tasks.js';
 async function initUserCmds(cmdFeats) {
     const paths = new Set();
     const cmds = new Array();
@@ -12,4 +23,73 @@ async function initUserCmds(cmdFeats) {
     }
     return cmds;
 }
-export { initUserCmds };
+async function resetDbCmd() {
+    if (runMode.value == "cli") {
+        console.log("This command can not be run in cli mode");
+        return;
+    }
+    deleteFileIfExists(dbPath);
+    console.log("Config database reset ok. Run the conf command to recreate it");
+}
+async function updateFeaturesCmd() {
+    const fp = readFeaturePaths();
+    const pp = await readPluginsPaths();
+    const paths = [...fp, ...pp];
+    const feats = readFeaturesDirs(paths);
+    updateFeatures(feats);
+    updateAliases(feats);
+    const deleted = cleanupFeaturePaths(paths);
+    for (const el of deleted) {
+        console.log("- [feature path]", el);
+    }
+}
+async function processTasksCmd(args, options) {
+    if (options?.conf) {
+        if (!isTaskSettingsInitialized.value) {
+            initTaskSettings();
+        }
+        console.log(YAML.stringify({ "tasks": tasksSettings }));
+    }
+    else {
+        const ts = Object.keys(readFeaturesType("task")).sort();
+        console.table(ts);
+    }
+}
+async function processTaskCmd(args, options) {
+    if (args.length == 0) {
+        console.warn("Provide a task name");
+        return;
+    }
+    const { found, path } = getFeatureSpec(args[0], "task");
+    if (!found) {
+        console.warn(`Task ${args[0]} not found`);
+        return;
+    }
+    if (options?.reset) {
+        deleteTaskSetting(args[0]);
+        console.log("Task", args[0], "reset ok");
+        return;
+    }
+    const res = readTask(path);
+    if (!res.found) {
+        throw new Error(`Task ${args[0]}, ${path} not found`);
+    }
+    console.log(res.ymlTask);
+    if (Object.keys(options).length > 0) {
+        upsertTaskSettings(args[0], options);
+    }
+    const s = readTaskSetting(args[0]);
+    if (s.found) {
+        const sts = s.settings;
+        delete sts.id;
+        delete sts.name;
+        const display = {};
+        for (const [k, v] of Object.entries(sts)) {
+            if (v) {
+                display[k] = v;
+            }
+        }
+        console.log(colors.dim("Settings") + ":", display);
+    }
+}
+export { initUserCmds, resetDbCmd, updateFeaturesCmd, processTaskCmd, processTasksCmd, };

package/dist/cmd/clicmds/update.js

@@ -4,7 +4,6 @@ import { readFilePath } from "../../db/read.js";
 import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, updatePromptfilePath, upsertFilePath } from "../../db/write.js";
 import { readFeaturesDirs } from "../../state/features.js";
 import { dataDirPath, promptfilePath } from "../../state/state.js";
-import { updateAllModels } from '../lib/models.js';
 import { runtimeDataError, runtimeInfo } from '../lib/user_msgs.js';
 async function updateConfCmd(args) {
     initDb(false, true);
@@ -37,7 +36,6 @@ async function updateConfCmd(args) {
     const feats = readFeaturesDirs(paths);
     updateFeatures(feats);
     updateAliases(feats);
-    updateAllModels();
     const deleted = cleanupFeaturePaths(paths);
     for (const el of deleted) {
         console.log("- [feature path]", el);

package/dist/cmd/cmds.d.ts

@@ -1,6 +1,7 @@
+import { InferenceOptions } from "@locallm/types/dist/inference.js";
 import { Command } from "commander";
 declare const program: Command;
-declare function chat(program: Command): Promise<void>;
+declare function chat(program: Command, options: InferenceOptions): Promise<void>;
 declare function buildCmds(): Promise<Command>;
 declare function parseCmd(program: Command): Promise<void>;
-export { program, buildCmds, chat, parseCmd, };
+export { buildCmds, chat, parseCmd, program };

package/dist/cmd/cmds.js

@@ -1,15 +1,14 @@
 import { input } from "@inquirer/prompts";
-import { toRaw } from "@vue/reactivity";
 import { Command } from "commander";
 import { query } from "../cli.js";
 import { readAliases, readFeatures } from "../db/read.js";
-import { chatInferenceParams } from "../state/chat.js";
+import { chatInferenceParams, chatTemplate } from "../state/chat.js";
 import { agent, isChatMode, runMode } from "../state/state.js";
 import { initCommandsFromAliases } from "./clicmds/aliases.js";
 import { initBaseCommands } from "./clicmds/base.js";
 import { initUserCmds } from "./clicmds/cmds.js";
 const program = new Command();
-async function chat(program) {
+async function chat(program, options) {
     const data = { message: '>', default: "" };
     const prompt = await input(data);
     if (prompt == "/q") {
@@ -21,9 +20,10 @@ async function chat(program) {
             await query(program);
         }
     }
-    await agent.lm.infer(prompt, toRaw(chatInferenceParams));
+    options.history = undefined;
+    await agent.run(prompt, chatInferenceParams, options, chatTemplate ? chatTemplate : undefined);
     console.log();
-    await chat(program);
+    await chat(program, options);
 }
 async function buildCmds() {
     initBaseCommands(program);
@@ -41,4 +41,4 @@ async function parseCmd(program) {
     program.description('Terminal agents toolkit');
     await program.parseAsync();
 }
-export { program, buildCmds, chat, parseCmd, };
+export { buildCmds, chat, parseCmd, program };

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

@@ -5,7 +5,7 @@ function createJsAction(action) {
             return res;
         }
         catch (e) {
-            throw new Error(`executing action:${e}`);
+            throw new Error(`executing action:${e}. Args: ${args}`);
         }
     };
     return run;

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

@@ -1,19 +1,27 @@
-import { input } from "@inquirer/prompts";
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
 import { default as color, default as colors } from "ansi-colors";
 import { PromptTemplate } from "modprompt";
 import ora from 'ora';
-import { query } from "../../../cli.js";
-import { readClipboard } from "../../../cmd/sys/clipboard.js";
 import { usePerfTimer } from "../../../main.js";
-import { isChatMode, runMode, agent } from "../../../state/state.js";
-import { program } from "../../cmds.js";
+import { backend, backends, listBackends } from "../../../state/backends.js";
+import { setChatInferenceParams, setChatTemplate } from "../../../state/chat.js";
+import { agent, isChatMode } from "../../../state/state.js";
+import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from "../../../state/tasks.js";
+import { chat, program } from "../../cmds.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeError, runtimeWarning } from "../user_msgs.js";
-import { formatStats, processOutput, readPromptFile } from "../utils.js";
+import { formatStats, processOutput } from "../utils.js";
 import { readTask } from "./read.js";
-import { backend, backends, listBackends } from "../../../state/backends.js";
+import { getTaskPrompt } from "./utils.js";
 async function executeTask(name, payload, options, quiet) {
+    if (!isTaskSettingsInitialized.value) {
+        initTaskSettings();
+    }
+    const hasSettings = Object.keys(tasksSettings).includes(name);
+    let settings = {};
+    if (hasSettings) {
+        settings = tasksSettings[name];
+    }
     if (options?.backend) {
         if (options.backend in backends) {
             agent.lm = backends[options.backend];
@@ -23,10 +31,45 @@ async function executeTask(name, payload, options, quiet) {
             runtimeDataError(`The backend ${options.backend} is not registered in config. Available backends:\n`, bks);
         }
     }
+    else if (settings?.backend) {
+        agent.lm = backends[settings.backend];
+    }
     if (options?.debug || options?.backend) {
         console.log("Agent:", colors.bold(agent.lm.name), "( " + agent.lm.providerType + " backend type)");
     }
     const { task, model, conf, vars, mcpServers } = await readTask(name, payload, options, agent);
+    if (hasSettings) {
+        if (!model?.inferParams) {
+            model.inferParams = {};
+        }
+        if (settings?.model && !conf?.model?.name) {
+            model.name = settings.model;
+        }
+        if (settings?.template && !conf?.model?.template) {
+            model.template = settings.template;
+        }
+        if (settings?.ctx && !conf?.model?.ctx) {
+            model.ctx = settings.ctx;
+        }
+        if (settings?.max_tokens && !conf?.inferParams?.max_tokens) {
+            model.inferParams.max_tokens = settings.max_tokens;
+        }
+        if (settings?.top_k && !conf?.inferParams?.top_k) {
+            model.inferParams.top_k = settings.top_k;
+        }
+        if (settings?.top_p && !conf?.inferParams?.top_p) {
+            model.inferParams.top_p = settings.top_p;
+        }
+        if (settings?.min_p && !conf?.inferParams?.min_p) {
+            model.inferParams.min_p = settings.min_p;
+        }
+        if (settings?.temperature && !conf?.inferParams?.temperature) {
+            model.inferParams.temperature = settings.temperature;
+        }
+        if (settings?.repeat_penalty && !conf?.inferParams?.repeat_penalty) {
+            model.inferParams.repeat_penalty = settings.repeat_penalty;
+        }
+    }
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
@@ -150,6 +193,8 @@ async function executeTask(name, payload, options, quiet) {
         onToolCallEnd: onToolCallEnd,
         ...conf,
     };
+    const initialInferParams = Object.assign({}, conf.inferParams);
+    initialInferParams.model = tconf.model;
     let out;
     try {
         out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
@@ -181,20 +226,11 @@ async function executeTask(name, payload, options, quiet) {
     mcpServers.forEach(async (s) => await s.stop());
     await processOutput(out);
     if (isChatMode.value) {
-        const data = { message: '>', default: "" };
-        const prompt = await input(data);
-        if (prompt == "/q") {
-            isChatMode.value = false;
-            if (runMode.value == "cmd") {
-                process.exit(0);
-            }
-            else {
-                await query(program);
-            }
-        }
-        else {
-            await executeTask(name, { ...vars, prompt: prompt }, options, quiet);
+        if (tpl) {
+            setChatTemplate(tpl);
         }
+        setChatInferenceParams(initialInferParams);
+        await chat(program, options);
     }
     if (options?.debug === true || options?.verbose === true) {
         try {
@@ -213,24 +249,8 @@ async function executeTask(name, payload, options, quiet) {
     return out;
 }
 async function executeTaskCmd(name, targs = []) {
-    const { args, options } = parseCommandArgs(targs);
-    let pr;
-    if (options?.clipboardInput === true) {
-        pr = await readClipboard();
-    }
-    else if (options?.inputFile === true) {
-        pr = readPromptFile();
-    }
-    else {
-        if (args[0] !== undefined) {
-            pr = args[0];
-        }
-        else {
-            runtimeDataError("task", name, "provide a prompt or use input options");
-            throw new Error();
-        }
-    }
-    const params = { args: args, prompt: pr };
-    return await executeTask(name, params, options);
+    const ca = parseCommandArgs(targs);
+    const prompt = await getTaskPrompt(name, ca.args, ca.options);
+    return await executeTask(name, { prompt: prompt }, ca.options);
 }
 export { executeTask, executeTaskCmd };

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

@@ -92,6 +92,7 @@ async function readTask(name, payload, options, agent) {
     }
     ;
     const task = new Task(agent, taskSpec);
+    task.addTools(taskSpec.tools);
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;

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

@@ -1,3 +1,4 @@
 import { LmTaskFileSpec } from "../../../interfaces.js";
 declare function openTaskSpec(name: string): LmTaskFileSpec;
-export { openTaskSpec, };
+declare function getTaskPrompt(name: string, args: Array<string>, options: Record<string, any>): Promise<string>;
+export { openTaskSpec, getTaskPrompt, };

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

@@ -1,6 +1,9 @@
 import YAML from 'yaml';
 import { readTask } from "../../../cmd/sys/read_task.js";
 import { getFeatureSpec } from "../../../state/features.js";
+import { readClipboard } from '../../../cmd/sys/clipboard.js';
+import { readPromptFile } from '../utils.js';
+import { runtimeDataError } from '../user_msgs.js';
 function openTaskSpec(name) {
     const { found, path } = getFeatureSpec(name, "task");
     if (!found) {
@@ -14,4 +17,23 @@ function openTaskSpec(name) {
     taskFileSpec.name = name;
     return taskFileSpec;
 }
-export { openTaskSpec, };
+async function getTaskPrompt(name, args, options) {
+    let pr;
+    if (options?.clipboardInput === true) {
+        pr = await readClipboard();
+    }
+    else if (options?.inputFile === true) {
+        pr = readPromptFile();
+    }
+    else {
+        if (args[0] !== undefined) {
+            pr = args[0];
+        }
+        else {
+            runtimeDataError("task", name, "provide a prompt or use input options");
+            throw new Error();
+        }
+    }
+    return pr;
+}
+export { openTaskSpec, getTaskPrompt, };

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

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

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

@@ -2,30 +2,51 @@ import { executeAction } from "../actions/cmd.js";
 import { executeAdaptater } from "../adaptaters/cmd.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { executeTask } from "../tasks/cmd.js";
+import { getTaskPrompt } from "../tasks/utils.js";
 import { readWorkflow } from "./read.js";
 import colors from "ansi-colors";
-async function executeWorkflow(name, args, options = {}) {
-    const { workflow, found } = await readWorkflow(name);
+async function executeWorkflow(wname, args, options = {}) {
+    const { workflow, found } = await readWorkflow(wname);
     if (!found) {
-        throw new Error(`Workflow ${name} not found`);
+        throw new Error(`Workflow ${wname} not found`);
     }
     const isDebug = options?.debug === true;
     const isVerbose = options?.verbose === true;
     const stepNames = Object.keys(workflow);
     if (isDebug || isVerbose) {
-        console.log("Running workflow", name, stepNames.length, "steps");
+        console.log("Running workflow", wname, stepNames.length, "steps");
     }
     let i = 0;
     const finalTaskIndex = stepNames.length - 1;
     let taskRes = { cmdArgs: args };
-    for (const [name, step] of Object.entries(workflow)) {
+    let prevStepType = null;
+    for (const step of workflow) {
         if (isDebug || isVerbose) {
-            console.log(i + 1, name, colors.dim(step.type));
+            console.log(i + 1, step.name, colors.dim(step.type));
         }
         switch (step.type) {
             case "task":
                 try {
-                    const tr = await executeTask(name, taskRes, options, true);
+                    let pr = null;
+                    if (i == 0) {
+                        pr = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
+                    }
+                    else {
+                        if (prevStepType) {
+                            if (prevStepType == "task") {
+                                pr = taskRes.answer.text;
+                            }
+                        }
+                        if (!pr) {
+                            if (taskRes?.prompt) {
+                                pr = taskRes.prompt;
+                            }
+                        }
+                    }
+                    if (!pr) {
+                        throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${name}`);
+                    }
+                    const tr = await executeTask(step.name, { prompt: pr }, options, true);
                     taskRes = { ...tr, ...taskRes };
                 }
                 catch (e) {
@@ -35,7 +56,7 @@ async function executeWorkflow(name, args, options = {}) {
             case "action":
                 try {
                     const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
-                    const ares = await executeAction(name, actArgs, options, true);
+                    const ares = await executeAction(step.name, actArgs, options, true);
                     if (typeof ares == "string" || Array.isArray(ares)) {
                         taskRes.args = ares;
                     }
@@ -53,7 +74,7 @@ async function executeWorkflow(name, args, options = {}) {
             case "adaptater":
                 try {
                     const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
-                    const adres = await executeAdaptater(name, actArgs, options);
+                    const adres = await executeAdaptater(step.name, actArgs, options);
                     if (typeof adres == "string" || Array.isArray(adres)) {
                         taskRes.args = adres;
                     }
@@ -71,6 +92,7 @@ async function executeWorkflow(name, args, options = {}) {
             default:
                 throw new Error(`unknown task type ${step.type} in workflow ${name}`);
         }
+        prevStepType = step.type;
         ++i;
     }
     return taskRes;

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

@@ -1,6 +1,6 @@
 import { WorkflowStep } from '../../../interfaces.js';
 declare function readWorkflow(name: string): Promise<{
     found: boolean;
-    workflow: Record<string, WorkflowStep>;
+    workflow: Array<WorkflowStep>;
 }>;
 export { readWorkflow };