@agent-smith/cli 0.0.63 → 0.0.65

package/dist/cli.d.ts

@@ -1,2 +1,3 @@
-declare function query(sign?: string): Promise<void>;
+import { Command } from 'commander/typings/index.js';
+declare function query(program: Command): Promise<void>;
 export { query };

package/dist/cli.js

@@ -1,55 +1,14 @@
 import { input } from '@inquirer/prompts';
-import { chat, runCmd } from './cmd/cmds.js';
+import { chat } from './cmd/cmds.js';
 import { isChatMode } from './state/state.js';
-import { setOptions } from './cmd/lib/utils.js';
-import { modes } from './cmd/clicmds/modes.js';
-function parseParams(params) {
-    const regex = /"([^"]*)"|(\S+)/g;
-    let match;
-    const result = new Array();
-    while ((match = regex.exec(params)) !== null) {
-        if (match[1]) {
-            result.push(match[1]);
-        }
-        else {
-            result.push(match[2]);
-        }
-    }
-    return result;
-}
-async function dispatch(input) {
-    if (input.startsWith("-")) {
-        try {
-            const _cmd = modes[input].cmd;
-            await _cmd([], {});
-            return;
-        }
-        catch (e) {
-            throw new Error(`Option error ${e}`);
-        }
-    }
-    const buf = new Array();
-    let params = parseParams(input);
-    const cmd = params.shift();
-    const opts = {};
-    params.forEach((p) => {
-        if (p.startsWith("-")) {
-            opts[p.substring(1)] = true;
-        }
-        else {
-            buf.push(p);
-        }
-    });
-    const args = await setOptions(buf, opts);
-    await runCmd(cmd, args);
-}
-async function query(sign = "$") {
-    const data = { message: sign, default: "" };
+async function query(program) {
+    const data = { message: "$", default: "" };
     const q = await input(data);
-    await dispatch(q);
+    const args = q.split(" ");
+    await program.parseAsync(args, { from: "user" });
     if (isChatMode.value) {
-        await chat();
+        await chat(program);
     }
-    await query(sign);
+    await query(program);
 }
 export { query };

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

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { AliasType, FeatureSpec, FeatureType } from "../../interfaces.js";
+declare function initCommandsFromAliases(program: Command, aliases: {
+    name: string;
+    type: AliasType;
+}[], features: Record<FeatureType, Record<string, FeatureSpec>>): Command;
+export { initCommandsFromAliases, };

package/dist/cmd/clicmds/aliases.js

@@ -0,0 +1,43 @@
+import { actionOptions, taskOptions, workflowOptions } from "../options.js";
+import { executeTaskCmd } from "../lib/tasks/cmd.js";
+import { executeActionCmd } from "../lib/actions/cmd.js";
+import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
+function initCommandsFromAliases(program, aliases, features) {
+    aliases.forEach((alias) => {
+        switch (alias.type) {
+            case "task":
+                const tcmd = program.command(`${alias.name} [prompt_and_vars...]`)
+                    .description("task: " + alias.name)
+                    .action(async (...args) => {
+                    await executeTaskCmd(alias.name, args);
+                });
+                taskOptions.forEach(o => tcmd.addOption(o));
+                if (features.task[alias.name]?.variables) {
+                    features.task[alias.name].variables?.optional.forEach(v => {
+                        tcmd.option(`--${v} <value>`);
+                    });
+                    features.task[alias.name].variables?.required.forEach(v => {
+                        tcmd.requiredOption(`--${v} <value>`);
+                    });
+                }
+                break;
+            case "action":
+                const acmd = program.command(`${alias.name} [args...]`)
+                    .description("action: " + alias.name)
+                    .action(async (...args) => {
+                    await executeActionCmd(alias.name, args);
+                });
+                actionOptions.forEach(o => acmd.addOption(o));
+                break;
+            case "workflow":
+                const wcmd = program.command(`${alias.name} [args...]`)
+                    .description("workflow: " + alias.name)
+                    .action(async (...args) => {
+                    executeWorkflowCmd(alias.name, args);
+                });
+                workflowOptions.forEach(o => wcmd.addOption(o));
+        }
+    });
+    return program;
+}
+export { initCommandsFromAliases, };

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

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare function initBaseCommands(program: Command): Command;
+export { initBaseCommands };

package/dist/cmd/clicmds/base.js

@@ -0,0 +1,94 @@
+import YAML from 'yaml';
+import { initAgent, taskBuilder } from "../../agent.js";
+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 { parseCommandArgs } from "../lib/options_parsers.js";
+import { deleteFileIfExists } from "../sys/delete_file.js";
+import { readTask } from "../sys/read_task.js";
+import { updateConfCmd } from "./update.js";
+function initBaseCommands(program) {
+    program.command("ping")
+        .description("ping inference servers")
+        .action(async (...args) => { console.log("Found working inference server(s):", await initAgent()); });
+    program.command("exit")
+        .description("exit the cli")
+        .action(() => process.exit(0));
+    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);
+    });
+    program.command("models [filters...]")
+        .description("list the available models")
+        .action(async (...args) => {
+        const ca = parseCommandArgs(args);
+        await showModelsCmd(ca.args);
+    });
+    program.command("update")
+        .description("update the available features: run this after adding a new feature")
+        .action(async (...args) => {
+        await _updateFeatures();
+    });
+    program.command("conf <path>")
+        .description("process config file")
+        .action(async (...args) => {
+        const ca = parseCommandArgs(args);
+        await updateConfCmd(ca.args);
+    });
+    program.command("reset")
+        .description("reset the config database")
+        .action(async (...args) => {
+        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`);
+    }
+    const ts = taskBuilder.readFromYaml(res.ymlTask);
+    console.log(YAML.stringify(ts));
+}
+export { initBaseCommands };

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

@@ -1,7 +1,4 @@
-import { Cmd } from "../../interfaces.js";
-declare let cmds: Record<string, Cmd>;
-declare function initAliases(): Record<string, Cmd>;
-declare function initCmds(): Promise<Record<string, Cmd>>;
-declare function pingCmd(args: Array<string> | undefined, options: any): Promise<boolean>;
-declare function updateConfCmd(args: Array<string> | undefined, options: any): Promise<any>;
-export { cmds, initCmds, pingCmd, initAliases, updateConfCmd };
+import { Command } from 'commander';
+import { FeatureSpec } from '../../interfaces.js';
+declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>): Promise<Array<Command>>;
+export { initUserCmds };

package/dist/cmd/clicmds/cmds.js

@@ -1,188 +1,10 @@
-import YAML from 'yaml';
-import { dataDirPath, isChatMode, isDebug, promptfilePath, runMode } from "../../state/state.js";
-import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
-import { readAliases, readFeaturePaths, readFeatures, readFilePath } from "../../db/read.js";
-import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, upsertFilePath, updatePromptfilePath } from "../../db/write.js";
-import { processConfPath } from "../../conf.js";
-import { executeActionCmd } from "../lib/actions/cmd.js";
-import { initAgent, taskBuilder } from "../../agent.js";
-import { executeTaskCmd } from "../lib/tasks/cmd.js";
 import { readCmds } from "../sys/read_cmds.js";
-import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
-import { readTask } from "../sys/read_task.js";
-import { deleteFileIfExists } from "../sys/delete_file.js";
-import { dbPath, initDb } from "../../db/db.js";
-import { showModelsCmd, updateAllModels } from '../lib/models.js';
-import { readPluginsPaths } from '../../state/plugins.js';
-import { runtimeDataError, runtimeInfo } from '../lib/user_msgs.js';
-let cmds = {
-    exit: {
-        cmd: async () => process.exit(0),
-        description: "exit the cli"
-    },
-    ping: {
-        cmd: async () => pingCmd(["verbose"], undefined),
-        description: "ping inference servers",
-    },
-    tasks: {
-        cmd: _listTasksCmd,
-        description: "list all the tasks"
-    },
-    task: {
-        cmd: _readTaskCmd,
-        description: "read a task",
-        args: "arguments: \n-task (required): the task name"
-    },
-    models: {
-        cmd: showModelsCmd,
-        description: "list the available models",
-    },
-    update: {
-        cmd: _updateFeatures,
-        description: "update the available features: run this after adding a new feature",
-    },
-    conf: {
-        cmd: updateConfCmd,
-        description: "process config file",
-        args: "arguments: \n-path (required): the path to the config.yml file"
-    },
-    reset: {
-        cmd: _resetDbCmd,
-        description: "reset the config database",
-    },
-};
-function initAliases() {
-    const aliases = readAliases();
-    const _cmds = {};
-    aliases.forEach((alias) => {
-        switch (alias.type) {
-            case "task":
-                _cmds[alias.name] = {
-                    cmd: (args = [], options) => _executeTaskCmd([alias.name, ...args], options),
-                    description: "task: " + alias.name,
-                };
-                break;
-            case "action":
-                _cmds[alias.name] = {
-                    cmd: (args = [], options = {}, quiet = false) => executeActionCmd([alias.name, ...args], options, quiet),
-                    description: "action: " + alias.name,
-                };
-                break;
-            case "workflow":
-                _cmds[alias.name] = {
-                    cmd: (args = [], options) => _executeWorkflowCmd([alias.name, ...args], options),
-                    description: "wokflow: " + alias.name,
-                };
-        }
-    });
-    return _cmds;
-}
-async function initCmds() {
-    for (const dirpath of new Set(Object.values(readFeatures().cmd))) {
-        const c = await readCmds(`${dirpath}`);
-        cmds = { ...cmds, ...c };
+async function initUserCmds(cmdFeats) {
+    const cmds = new Array();
+    for (const feat of Object.values(cmdFeats)) {
+        const c = await readCmds(`${feat.path}`);
+        cmds.push(...c);
     }
     return cmds;
 }
-async function pingCmd(args = [], options) {
-    const isUp = await initAgent();
-    return isUp;
-}
-async function _updateFeatures(args = [], options) {
-    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 updateConfCmd(args = [], options) {
-    initDb(isDebug.value, true);
-    const { found, path } = readFilePath("conf");
-    const userProvidedConfPath = (args[0] != "conf") ? args[0] : null;
-    if (!found && !userProvidedConfPath) {
-        runtimeDataError("conf file path not found in db: please provide a conf path parameter to the command");
-    }
-    let confPath;
-    if (userProvidedConfPath) {
-        confPath = userProvidedConfPath;
-        const isu = upsertFilePath("conf", confPath);
-        if (isu) {
-            runtimeInfo("Config path", confPath, "updated");
-        }
-    }
-    else {
-        confPath = path;
-    }
-    console.log("Using", confPath, "to update features");
-    const { paths, pf, dd } = await processConfPath(confPath);
-    if (pf.length > 0) {
-        updatePromptfilePath(pf);
-        promptfilePath.value = pf;
-    }
-    if (dd.length > 0) {
-        updateDataDirPath(dd);
-        dataDirPath.value = dd;
-    }
-    const feats = readFeaturesDirs(paths);
-    updateFeatures(feats);
-    updateAliases(feats);
-    updateAllModels();
-    const deleted = cleanupFeaturePaths(paths);
-    for (const el of deleted) {
-        console.log("- [feature path]", el);
-    }
-}
-async function _resetDbCmd(args = [], options) {
-    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 _executeTaskCmd(args = [], options) {
-    if (args.length == 0) {
-        console.warn("Provide a task name");
-        return;
-    }
-    const res = await executeTaskCmd(args, options);
-    if (isChatMode.value) {
-    }
-    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");
-        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`);
-    }
-    const ts = taskBuilder.readFromYaml(res.ymlTask);
-    console.log(YAML.stringify(ts));
-}
-async function _listTasksCmd(args = [], options) {
-    const ts = Object.keys(readFeatures().task).sort();
-    console.table(ts);
-}
-export { cmds, initCmds, pingCmd, initAliases, updateConfCmd };
+export { initUserCmds };

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

@@ -0,0 +1,2 @@
+declare function updateConfCmd(args: Array<string>): Promise<any>;
+export { updateConfCmd, };

package/dist/cmd/clicmds/update.js

@@ -0,0 +1,46 @@
+import { processConfPath } from "../../conf.js";
+import { initDb } from "../../db/db.js";
+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);
+    const { found, path } = readFilePath("conf");
+    const userProvidedConfPath = (args[0] != "conf") ? args[0] : null;
+    if (!found && !userProvidedConfPath) {
+        runtimeDataError("conf file path not found in db: please provide a conf path parameter to the command");
+    }
+    let confPath;
+    if (userProvidedConfPath) {
+        confPath = userProvidedConfPath;
+        const isu = upsertFilePath("conf", confPath);
+        if (isu) {
+            runtimeInfo("Config path", confPath, "updated");
+        }
+    }
+    else {
+        confPath = path;
+    }
+    console.log("Using", confPath, "to update features");
+    const { paths, pf, dd } = await processConfPath(confPath);
+    if (pf.length > 0) {
+        updatePromptfilePath(pf);
+        promptfilePath.value = pf;
+    }
+    if (dd.length > 0) {
+        updateDataDirPath(dd);
+        dataDirPath.value = dd;
+    }
+    const feats = readFeaturesDirs(paths);
+    updateFeatures(feats);
+    updateAliases(feats);
+    updateAllModels();
+    const deleted = cleanupFeaturePaths(paths);
+    for (const el of deleted) {
+        console.log("- [feature path]", el);
+    }
+}
+export { updateConfCmd, };

package/dist/cmd/cmds.d.ts

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

package/dist/cmd/cmds.js

@@ -3,13 +3,13 @@ import { toRaw } from "@vue/reactivity";
 import { Command } from "commander";
 import { brain } from "../agent.js";
 import { query } from "../cli.js";
+import { readAliases, readFeatures } from "../db/read.js";
 import { chatInferenceParams } from "../state/chat.js";
-import { isChatMode, lastCmd, runMode } from "../state/state.js";
-import { cmds, initAliases, initCmds } from "./clicmds/cmds.js";
-import { modes } from "./clicmds/modes.js";
-import { processOutput, setOptions } from "./lib/utils.js";
-let cliCmds = {};
-async function chat() {
+import { isChatMode, runMode } from "../state/state.js";
+import { initCommandsFromAliases } from "./clicmds/aliases.js";
+import { initBaseCommands } from "./clicmds/base.js";
+import { initUserCmds } from "./clicmds/cmds.js";
+async function chat(program) {
     const data = { message: '>', default: "" };
     const prompt = await input(data);
     if (prompt == "/q") {
@@ -18,63 +18,29 @@ async function chat() {
             process.exit(0);
         }
         else {
-            await query();
+            await query(program);
         }
     }
     await brain.ex.think(prompt, toRaw(chatInferenceParams));
     console.log();
-    await chat();
-}
-async function initCliCmds() {
-    const _cmds = await initCmds();
-    const _alias = initAliases();
-    cliCmds = { ..._cmds, ..._alias };
-}
-async function runCmd(cmdName, args = [], options = {}) {
-    if (!(cmdName in cliCmds)) {
-        console.log(`Command ${cmdName} not found`);
-        return;
-    }
-    const cmd = cliCmds[cmdName].cmd;
-    await cmd(args, options);
-    lastCmd.name = cmdName;
-    lastCmd.args = args;
+    await chat(program);
 }
 async function buildCmds() {
     const program = new Command();
-    const aliases = initAliases();
-    const excmds = await initCmds();
-    for (const [name, spec] of Object.entries({ ...cmds, ...excmds, ...aliases })) {
-        const cmd = program.command(name);
-        const _cmd = async (args = [], options = {}) => {
-            const _args = await setOptions(args, options);
-            const res = await spec.cmd(_args, options);
-            await processOutput(res);
-            return res;
-        };
-        if ("args" in spec) {
-            cmd
-                .argument("<args...>", spec.args)
-                .description(spec.description)
-                .action(_cmd);
-        }
-        else {
-            cmd
-                .argument("[args...]", "No arguments")
-                .description(spec.description)
-                .action(_cmd);
-        }
-        for (const [_name, _spec] of Object.entries(modes)) {
-            cmd.option(_name, _spec.description);
-        }
-    }
+    initBaseCommands(program);
+    const aliases = readAliases();
+    const feats = readFeatures();
+    initCommandsFromAliases(program, aliases, feats);
+    const cmds = await initUserCmds(feats.cmd);
+    cmds.forEach(c => {
+        program.addCommand(c);
+    });
     return program;
 }
-async function parseCmd() {
-    const program = await buildCmds();
+async function parseCmd(program) {
     await program.parseAsync();
     if (isChatMode.value) {
-        await chat();
+        await chat(program);
     }
 }
-export { buildCmds, chat, initCliCmds, parseCmd, runCmd };
+export { buildCmds, chat, parseCmd, };

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

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