@agent-smith/cli 0.0.1

package/dist/agent.d.ts

@@ -0,0 +1,15 @@
+import { marked } from 'marked';
+import { RunMode } from "./interfaces.js";
+declare let brain: import("@agent-smith/brain").AgentBrain;
+declare const modelsForExpert: Record<string, string>;
+declare const taskReader: {
+    init: (taskPath: string) => import("@agent-smith/jobs").AgentTask;
+    read: (taskPath: string) => {
+        found: boolean;
+        task: import("@agent-smith/lmtask").LmTask;
+    };
+    readDir: (dir: string) => Array<string>;
+};
+declare function clearOutput(): void;
+declare function initAgent(mode: RunMode, isVerbose?: boolean): Promise<boolean>;
+export { brain, initAgent, clearOutput, marked, modelsForExpert, taskReader };

package/dist/agent.js

@@ -0,0 +1,47 @@
+import { useAgentBrain } from "@agent-smith/brain";
+import { useLmTask } from "@agent-smith/lmtask";
+import logUpdate from 'log-update';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { formatMode } from "./state/state.js";
+marked.use(markedTerminal());
+let brain = useAgentBrain();
+const modelsForExpert = {};
+const taskReader = useLmTask(brain);
+async function initExperts() {
+    brain.experts.forEach((ex) => {
+        ex.setOnStartEmit(() => console.log("Start emitting"));
+        ex.setOnToken((t) => {
+            if (formatMode.value == "markdown") {
+                logUpdate(marked.parse(ex.stream.get() + t).trim());
+            }
+            else {
+                logUpdate((ex.stream.get() + t).trim());
+            }
+        });
+    });
+}
+function clearOutput() {
+    logUpdate.clear();
+}
+async function initAgent(mode, isVerbose = false) {
+    if (!brain.state.get().isOn) {
+        brain.resetExperts();
+        await brain.discoverLocal();
+        await initExperts();
+        await brain.expertsForModelsInfo();
+    }
+    const brainUp = brain.state.get().isOn;
+    if (isVerbose) {
+        if (!brainUp) {
+            console.log("❌ No experts found for inference");
+        }
+        else {
+            brain.experts.forEach((ex) => {
+                console.log(`✅ Expert ${ex.name} is up`);
+            });
+        }
+    }
+    return brainUp;
+}
+export { brain, initAgent, clearOutput, marked, modelsForExpert, taskReader };

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+declare function query(_default?: string): Promise<void>;
+export { query };

package/dist/cli.js

@@ -0,0 +1,44 @@
+import { input } from '@inquirer/prompts';
+import { runCmd } from './cmd/cmds.js';
+import { lastCmd, inputMode } from './state/state.js';
+import { readPromptFile } from './cmd/lib/utils.js';
+import { readClipboard } from './cmd/sys/clipboard.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) {
+    let buf = new Array();
+    buf = parseParams(input);
+    const cmd = buf.shift();
+    if (inputMode.value == "promptfile") {
+        const p = readPromptFile();
+        buf.push(p);
+    }
+    else if (inputMode.value == "clipboard") {
+        const p = await readClipboard();
+        buf.push(p);
+    }
+    await runCmd(cmd, buf);
+}
+async function query(_default) {
+    const data = { message: '>', default: "" };
+    if (_default) {
+        data.default = _default;
+    }
+    const answer = await input(data);
+    await dispatch(answer);
+    const lc = lastCmd.name + " " + lastCmd.args.join(" ");
+    await query(lc);
+}
+export { query };

package/dist/cmd/cmds.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "@commander-js/extra-typings";
+declare function initCmds(): Promise<void>;
+declare function runCmd(cmdName: string, args?: Array<string>): Promise<void>;
+declare function pingCmd(args: Array<string> | undefined, options: any): Promise<boolean>;
+declare function buildCmds(): Promise<Command>;
+declare function parseCmd(): Promise<void>;
+export { initCmds, runCmd, buildCmds, parseCmd, pingCmd };

package/dist/cmd/cmds.js

@@ -0,0 +1,205 @@
+import { Command } from "@commander-js/extra-typings";
+import { formatMode, initFeatures, lastCmd, runMode } from "../state/state.js";
+import { modes } from "./options/modes.js";
+import { executeTaskCmd } from "./lib/execute_task.js";
+import { clearOutput, initAgent, marked, taskReader } from "../agent.js";
+import { executeActionCmd } from "./lib/execute_action.js";
+import { executeJobCmd, readJob } from "./lib/execute_job.js";
+import { readCmds } from "./sys/read_cmds.js";
+import { processOutput, setOptions } from "./lib/utils.js";
+import { getFeatureSpec, readFeaturesDirs } from "../state/features.js";
+import { readFeatures } from "../db/read.js";
+import { insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures } from "../db/write.js";
+import { readConf } from "./sys/read_conf.js";
+import { buildPluginsPaths } from "../state/plugins.js";
+let cmds = {
+    q: {
+        cmd: async () => process.exit(0),
+        description: "exit the cli"
+    },
+    ping: {
+        cmd: async () => pingCmd(["verbose"], undefined),
+        description: "ping inference servers",
+    },
+    lt: {
+        cmd: _listTasksCmd,
+        description: "list all the tasks"
+    },
+    rt: {
+        cmd: _readTaskCmd,
+        description: "read a task",
+        args: "arguments: \n-task (required): the task name"
+    },
+    rj: {
+        cmd: _readJobCmd,
+        description: "read a job",
+        args: "arguments: \n-job (required): the job name"
+    },
+    t: {
+        cmd: _executeTaskCmd,
+        description: "execute a task",
+        args: "arguments: \n-task (required): the task name\n-args: prompt and other arguments if any for the task"
+    },
+    j: {
+        cmd: _executeJobCmd,
+        description: "execute a job",
+        args: "arguments: \n-job (required): the job name\n-args: arguments if any for the job"
+    },
+    a: {
+        cmd: executeActionCmd,
+        description: "execute an action",
+        args: "arguments: \n-action (required): the task name\n-args: other arguments if any for the action"
+    },
+    conf: {
+        cmd: _updateConfCmd,
+        description: "process config file",
+        args: "arguments: \n-path (required): the path to the config.yml file"
+    },
+    update: {
+        cmd: _updateFeaturesCmd,
+        description: "reparse the features dirs and update the list",
+    }
+};
+let cliCmds = { ...cmds, ...modes };
+async function initCmds() {
+    for (const dirpath of new Set(Object.values(readFeatures().cmd))) {
+        const c = await readCmds(`${dirpath}`);
+        cmds = { ...cmds, ...c };
+    }
+    cliCmds = { ...cmds, ...modes };
+}
+async function _updateFeaturesCmd(args = [], options) {
+    await initFeatures();
+    console.log("Features updated");
+}
+async function _updateConfCmd(args = [], options) {
+    if (args.length == 0) {
+        console.warn("Provide a config.yml file path");
+        return;
+    }
+    const { found, data } = readConf(args[0]);
+    if (!found) {
+        console.warn(`Config file ${args[0]} not found`);
+    }
+    const p = new Array();
+    if ("features" in data) {
+        p.push(...data.features);
+        const fts = new Array();
+        data.features.forEach((f) => {
+            if (!fts.includes(f)) {
+                insertFeaturesPathIfNotExists(f);
+                fts.push(f);
+            }
+        });
+    }
+    if ("plugins" in data) {
+        const plugins = await buildPluginsPaths(data.plugins);
+        plugins.forEach((_pl) => {
+            p.push(_pl.path);
+            insertPluginIfNotExists(_pl.name, _pl.path);
+        });
+    }
+    const feats = readFeaturesDirs(p);
+    updateFeatures(feats);
+}
+async function _readJobCmd(args = [], options) {
+    if (args.length == 0) {
+        console.warn("Provide a job name");
+        return;
+    }
+    const t = await readJob(args[0]);
+    console.log(t.data);
+}
+async function _executeTaskCmd(args = [], options) {
+    if (args.length == 0) {
+        console.warn("Provide a task name");
+        return;
+    }
+    const { ok, data, error } = await executeTaskCmd(args);
+    if (!ok) {
+        console.warn(error);
+    }
+    clearOutput();
+    if (formatMode.value == "markdown") {
+        console.log(marked.parse(data).trim());
+    }
+    else {
+        console.log(data);
+    }
+    return data;
+}
+async function _executeJobCmd(args = [], options) {
+    if (args.length == 0) {
+        console.warn("Provide a job name");
+        return;
+    }
+    const name = args.shift();
+    const t = await executeJobCmd(name, args);
+}
+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 r = taskReader.read(path);
+    console.log(r.task);
+}
+async function _listTasksCmd(args = [], options) {
+    Object.keys(readFeatures().task).forEach((t) => console.log("-", t));
+}
+async function runCmd(cmdName, args = []) {
+    if (!(cmdName in cliCmds)) {
+        console.log(`Command ${cmdName} not found`);
+        return;
+    }
+    const cmd = cliCmds[cmdName].cmd;
+    await cmd(args, {});
+    lastCmd.name = cmdName;
+    lastCmd.args = args;
+}
+async function pingCmd(args = [], options) {
+    let _isVerbose = false;
+    if (args.length > 0) {
+        _isVerbose = args[0] == "verbose";
+    }
+    const isUp = await initAgent(runMode.value, _isVerbose);
+    return isUp;
+}
+async function buildCmds() {
+    const program = new Command();
+    for (const [name, spec] of Object.entries(cmds)) {
+        const cmd = program.command(name);
+        const _cmd = async (args = [], options = {}) => {
+            const _args = await setOptions(options, args);
+            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);
+        }
+    }
+    return program;
+}
+async function parseCmd() {
+    const program = await buildCmds();
+    await program.parseAsync();
+}
+export { initCmds, runCmd, buildCmds, parseCmd, pingCmd };

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

@@ -0,0 +1,2 @@
+declare function executeActionCmd(args?: Array<string>, options?: any, quiet?: boolean): Promise<any>;
+export { executeActionCmd };

package/dist/cmd/lib/execute_action.js

@@ -0,0 +1,58 @@
+import { useAgentTask } from "@agent-smith/jobs";
+import { getFeatureSpec } from '../../state/features.js';
+import { readYmlAction } from "../sys/read_yml_action.js";
+import { execute } from "../sys/execute.js";
+import { runPyScript } from "../sys/run_python.js";
+import { pyShell } from "../../state/state.js";
+function _systemAction(path) {
+    const action = useAgentTask({
+        id: "system_action",
+        title: "",
+        run: async (args) => {
+            const actionSpec = readYmlAction(path);
+            const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...args]);
+            return { data: out, error: "", ok: true };
+        }
+    });
+    return action;
+}
+function _pythonAction(path) {
+    const action = useAgentTask({
+        id: "python_action",
+        title: "",
+        run: async (args) => {
+            const out = await runPyScript(pyShell, "python3", path, args);
+            return { data: out[0], error: "", ok: true };
+        }
+    });
+    return action;
+}
+async function executeActionCmd(args = [], options = {}, quiet = false) {
+    const name = args.shift();
+    const { found, path, ext } = getFeatureSpec(name, "action");
+    if (!found) {
+        return { ok: false, data: {}, error: "FeatureType not found" };
+    }
+    let act;
+    switch (ext) {
+        case "js":
+            const { action } = await import(path);
+            act = action;
+            break;
+        case "yml":
+            act = _systemAction(path);
+            break;
+        case "py":
+            act = _pythonAction(path);
+            break;
+        default:
+            throw new Error(`Action ext ${ext} not implemented`);
+            break;
+    }
+    const res = await act.run(args);
+    if (!quiet) {
+        console.log(res.data);
+    }
+    return { ok: true, data: res.data, error: "" };
+}
+export { executeActionCmd };

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

@@ -0,0 +1,6 @@
+declare function executeJobCmd(name: string, args?: Array<any>): Promise<"" | Record<string, any>>;
+declare function readJob(name: string): Promise<{
+    found: boolean;
+    data: Record<string, any>;
+}>;
+export { readJob, executeJobCmd };

package/dist/cmd/lib/execute_job.js

@@ -0,0 +1,86 @@
+import YAML from 'yaml';
+import { default as fs } from "fs";
+import { useAgentJob } from "@agent-smith/jobs";
+import { brain, taskReader } from '../../agent.js';
+import { getFeatureSpec } from '../../state/features.js';
+async function executeJobCmd(name, args = []) {
+    const { job, found } = await _dispatchReadJob(name);
+    if (!found) {
+        console.log(`Job ${name} not found`);
+        return "";
+    }
+    await job.start();
+    let params = args;
+    let res = {};
+    for (const name of Object.keys(job.tasks)) {
+        brain.expertsForModelsInfo();
+        res = await job.runTask(name, params);
+        params = res.data;
+    }
+    await job.finish(true);
+    return res;
+}
+async function _dispatchReadJob(name) {
+    const { found, path, ext } = getFeatureSpec(name, "job");
+    if (!found) {
+        return { found: false, job: {} };
+    }
+    let jb;
+    switch (ext) {
+        case "js":
+            let { job } = await import(path);
+            jb = job;
+            break;
+        case "yml":
+            const { data } = await readJob(name);
+            const res = await _createJobFromSpec(data);
+            jb = res.job;
+            break;
+        default:
+            throw new Error(`Job extension ${ext} not implemented`);
+            break;
+    }
+    return { found: true, job: jb };
+}
+async function _createJobFromSpec(spec) {
+    const job = useAgentJob({
+        name: spec.name,
+        title: spec.title,
+        tasks: []
+    });
+    const tasks = {};
+    for (const t of spec.tasks) {
+        if (t.type == "action") {
+            const { found, path } = getFeatureSpec(t.name, "action");
+            if (!found) {
+                return { found: false, job: {} };
+            }
+            const { action } = await import(path);
+            tasks[t.name] = action;
+        }
+        else {
+            const { found, path } = getFeatureSpec(t.name, "task");
+            if (!found) {
+                return { found: false, job: {} };
+            }
+            const at = taskReader.init(path);
+            tasks[t.name] = at;
+        }
+    }
+    job.tasks = tasks;
+    return { job: job, found: true };
+}
+async function readJob(name) {
+    const { found, path, ext } = getFeatureSpec(name, "job");
+    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 };
+}
+export { readJob, executeJobCmd };

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

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

package/dist/cmd/lib/execute_task.js

@@ -0,0 +1,28 @@
+import { initAgent, taskReader } from "../../agent.js";
+import logUpdate from "log-update";
+import { getFeatureSpec } from "../../state/features.js";
+import { runMode } from "../../state/state.js";
+async function executeTaskCmd(args = [], options = {}) {
+    await initAgent(runMode.value);
+    const name = args.shift();
+    const { found, path } = getFeatureSpec(name, "task");
+    if (!found) {
+        return { ok: false, data: {}, error: `Task ${name} not found` };
+    }
+    const task = taskReader.init(path);
+    const pr = args.shift();
+    const vars = {};
+    args.forEach((a) => {
+        if (a.includes("=")) {
+            const t = a.split("=");
+            vars[t[0]] = t[1];
+        }
+    });
+    logUpdate("Ingesting prompt ...");
+    const data = await task.run({ prompt: pr, ...vars });
+    if (data?.error) {
+        return { ok: false, data: {}, error: `Error executing task: ${data.error}` };
+    }
+    return { ok: true, data: data.text, error: "" };
+}
+export { executeTaskCmd };

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

@@ -0,0 +1,4 @@
+declare function setOptions(options: Record<string, any>, args?: Array<string>): Promise<Array<string>>;
+declare function readPromptFile(): string;
+declare function processOutput(res: any): Promise<void>;
+export { readPromptFile, processOutput, setOptions, };

package/dist/cmd/lib/utils.js

@@ -0,0 +1,44 @@
+import { default as fs } from "fs";
+import { outputMode, promptfile } from "../../state/state.js";
+import { inputMode, runMode } from "../../state/state.js";
+import { readClipboard, writeToClipboard } from "../sys/clipboard.js";
+import { modes } from "../options/modes.js";
+async function setOptions(options, args = []) {
+    if (runMode.value == "cli") {
+        return args;
+    }
+    ;
+    for (const k of Object.keys(options)) {
+        const opt = modes["-" + k.toLowerCase()];
+        await opt.cmd([], undefined);
+    }
+    if (inputMode.value == "promptfile") {
+        const p = readPromptFile();
+        args.push(p);
+    }
+    else if (inputMode.value == "clipboard") {
+        const p = await readClipboard();
+        args.push(p);
+    }
+    return args;
+}
+function readPromptFile() {
+    const res = fs.readFileSync(promptfile.value, 'utf8');
+    return res;
+}
+async function processOutput(res) {
+    let data = "";
+    if (typeof res == "object") {
+        if (!res?.data) {
+            throw new Error(`No data in res: ${res}`);
+        }
+        data = res.data;
+    }
+    else {
+        data = res;
+    }
+    if (outputMode.value == "clipboard") {
+        await writeToClipboard(data);
+    }
+}
+export { readPromptFile, processOutput, setOptions, };

package/dist/cmd/options/modes.d.ts

@@ -0,0 +1,3 @@
+import { Cmd } from "../../interfaces.js";
+declare const modes: Record<string, Cmd>;
+export { modes };

package/dist/cmd/options/modes.js

@@ -0,0 +1,58 @@
+import { formatMode, inputMode, outputMode, runMode } from "../../state/state.js";
+const modes = {
+    "-if": {
+        cmd: async () => {
+            inputMode.value = "promptfile";
+            if (runMode.value == "cli") {
+                console.log("Prompt file input mode is on");
+            }
+        },
+        description: "use promptfile input mode",
+    },
+    "-ic": {
+        cmd: async () => {
+            inputMode.value = "clipboard";
+            if (runMode.value == "cli") {
+                console.log("Clipboard input mode is on");
+            }
+        },
+        description: "use clipboard input mode"
+    },
+    "-im": {
+        cmd: async () => {
+            inputMode.value = "manual";
+            if (runMode.value == "cli") {
+                console.log("Manual inputMode");
+            }
+        },
+        description: "use manual input mode (default)"
+    },
+    "-oc": {
+        cmd: async () => {
+            outputMode.value = "clipboard";
+            if (runMode.value == "cli") {
+                console.log("Clipboard output mode is on");
+            }
+        },
+        description: "use clipboard output mode"
+    },
+    "-omd": {
+        cmd: async () => {
+            formatMode.value = "markdown";
+            if (runMode.value == "cli") {
+                console.log("Markdown output mode");
+            }
+        },
+        description: "use markdown output (default)"
+    },
+    "-otxt": {
+        cmd: async () => {
+            formatMode.value = "text";
+            if (runMode.value == "cli") {
+                console.log("Text output mode");
+            }
+        },
+        description: "use text output "
+    },
+};
+export { modes };

package/dist/cmd/sys/clipboard.d.ts

@@ -0,0 +1,3 @@
+declare function readClipboard(): Promise<string>;
+declare function writeToClipboard(data: string): Promise<void>;
+export { readClipboard, writeToClipboard, };

package/dist/cmd/sys/clipboard.js

@@ -0,0 +1,17 @@
+import clipboard from 'clipboardy';
+import { execute } from "./execute.js";
+const { platform } = process;
+async function readClipboard() {
+    let res = "";
+    if (platform == "linux") {
+        res = await execute("xclip", ["-o", "-selection", "primary"]);
+    }
+    else {
+        res = await clipboard.read();
+    }
+    return res;
+}
+async function writeToClipboard(data) {
+    await clipboard.write(data);
+}
+export { readClipboard, writeToClipboard, };

package/dist/cmd/sys/execute.d.ts

@@ -0,0 +1,13 @@
+declare function execute(command: string, args?: Array<string>, { onStdout, onStderr, onError, stream, }?: {
+    onStderr?: (data: any) => void;
+    onError?: (err: any) => void;
+    onStdout?: ((data: any) => void) | undefined;
+    stream?: boolean | undefined;
+}): Promise<string>;
+declare function run(command: string, args?: Array<string>, { onStdout, onStderr, onError, onFinished, }?: {
+    onStdout?: (data: any) => void;
+    onStderr?: (data: any) => void;
+    onError?: (err: any) => void;
+    onFinished?: () => void;
+}): () => boolean;
+export { execute, run };