@agent-smith/cli 0.0.115 → 0.0.118

package/dist/cmd/callbacks.js

@@ -0,0 +1,90 @@
+import ora from "ora";
+import { printToken } from "../utils.js";
+import { default as color } from "ansi-colors";
+import { utils } from "@agent-smith/core";
+const useInferenceCallbacks = (agentName, options) => {
+    let emittedThinkingTokens = 0;
+    let emittedTokens = 0;
+    let isToolCallInProgress = false;
+    let isToolCallRunning = false;
+    const perfTimer = utils.usePerfTimer();
+    const spinner = ora({ discardStdin: false, color: "green" });
+    //const thinkIcon = "  ";
+    //const talkIcon = "🏁";
+    const toolIcon = "⚒️";
+    const onToken = (t, from) => {
+        if (emittedTokens == 0) {
+            perfTimer.start();
+            //console.log(talkIcon, from);
+        }
+        //if (!isToolCallRunning) {
+        printToken(t, options?.showTokens);
+        ++emittedTokens;
+        //}
+    };
+    const onStartThinking = (from) => {
+        //console.log("START THINKING");  
+        if (!options?.debug && !options?.verbose) {
+            spinner.start(`${from} is thinking ...`);
+        }
+    };
+    const onEndThinking = (from) => {
+        //console.log("END THINKING");
+        if (!options?.debug && !options?.verbose) {
+            spinner.stop();
+            let msg = `${color.dim("Thinking")} ${from} ${color.bold(emittedThinkingTokens.toString())} ${color.dim("tokens")}`;
+            msg = msg + " " + color.dim(perfTimer.time());
+            //const space = agentName == from ? thinkIcon + " " : `   ${thinkIcon} `;
+            const space = agentName == from ? "" : "   ";
+            console.log(space + msg);
+        }
+        emittedThinkingTokens = 0;
+    };
+    const onThinkingToken = (t, from) => {
+        if (options?.debug || options?.verbose) {
+            printToken(t, options?.showTokens, options?.showTokens ? false : true);
+        }
+        else {
+            let msg = `${color.dim("Thinking")} ${from} ${color.bold(emittedThinkingTokens.toString())} ${color.dim("tokens")}`;
+            msg = msg + " " + color.dim(perfTimer.time());
+            const space = agentName == from ? "" : "    ";
+            spinner.prefixText = space;
+            spinner.text = msg;
+        }
+        emittedThinkingTokens++;
+    };
+    const onToolCallInProgress = (tc, from) => {
+        const txt = color.dim("Preparing tool call") + ` ${from} ${color.yellowBright(tc[tc.length - 1].name)} ...`;
+        if (!isToolCallInProgress) {
+            spinner.start(txt);
+            isToolCallInProgress = true;
+        }
+        else {
+            spinner.text = txt;
+        }
+    };
+    const onToolCall = (tc, type, from) => {
+        isToolCallInProgress = false;
+        isToolCallRunning = true;
+        spinner.stop();
+        //console.log("TC START", type, "agent", agentName, "/", from);
+        const icon = agentName == from ? toolIcon + " " : "   " + toolIcon + " ";
+        console.log(icon, color.bold(from), "=>", type, `${color.yellowBright(tc.name)}`, tc.arguments);
+    };
+    const onToolCallEnd = (tc, tr, type, from) => {
+        isToolCallRunning = false;
+        if (options?.debug) {
+            console.log(tc.name, type, "from", from + ":\n", tr);
+        }
+    };
+    return {
+        onToken,
+        onStartThinking,
+        onEndThinking,
+        onThinkingToken,
+        onToolCallInProgress,
+        onToolCall,
+        onToolCallEnd,
+    };
+};
+export { useInferenceCallbacks, };

package/dist/cmd/cmds.d.ts

@@ -1,9 +1,8 @@
-import { InferenceOptions } from "@locallm/types/dist/inference.js";
-import { Command } from "commander";
-import type { McpClient } from "../main.js";
-import type { Agent } from "@agent-smith/agent";
-declare const program: Command;
-declare function chat(program: Command, options: InferenceOptions, agent: Agent, mcpServers: Array<McpClient>): Promise<void>;
-declare function buildCmds(): Promise<Command>;
-declare function parseCmd(program: Command): Promise<void>;
-export { buildCmds, chat, parseCmd, program };
+import { Command } from 'commander';
+import type { FeatureSpec } from '@agent-smith/types';
+declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>, program: Command): Promise<Array<Command>>;
+declare function resetDbCmd(): Promise<any>;
+declare function recreateDbCmd(): Promise<any>;
+declare function processAgentsCmd(args: Array<string>, options: Record<string, any>): Promise<void>;
+declare function processAgentCmd(args: Array<string>, options: Record<string, any>): Promise<any>;
+export { initUserCmds, processAgentCmd, processAgentsCmd, resetDbCmd, recreateDbCmd, };

package/dist/cmd/cmds.js

@@ -1,111 +1,142 @@
-import { input } from "@inquirer/prompts";
-import { Command } from "commander";
-import { query } from "../cli.js";
-import { readAliases, readFeatures } from "../db/read.js";
-import { chatInferenceParams, chatTemplate } from "../state/chat.js";
-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";
-//import { usePerfTimer } from "../main.js";
-const program = new Command();
-async function chat(program, options, agent, mcpServers) {
-    //console.log("CHAT OPTS", options);
-    const data = { message: '>', default: "" };
-    const prompt = await input(data);
-    if (prompt == "/q") {
-        isChatMode.value = false;
-        if (runMode.value == "cmd") {
-            process.exit(0);
+import colors from "ansi-colors";
+import { Option } from 'commander';
+import path from "path";
+import YAML from 'yaml';
+import { db, conf, utils, state, getFeatureSpec } from "@agent-smith/core";
+import { parseCommandArgs } from "../utils.js";
+import { readCmd } from "./read_cmds.js";
+import { runtimeDataError } from "../user_msgs.js";
+import { allOptions, displayOptions, inferenceOptions, ioOptions } from "../options.js";
+import { runMode } from "../state.js";
+async function initUserCmds(cmdFeats, program) {
+    const features = Object.values(cmdFeats);
+    const usrCmds = [];
+    for (const feat of features) {
+        //console.log("Init cmd", feat);
+        const hasVariables = feat?.variables ? true : false;
+        const vars = hasVariables ? feat.variables : {};
+        let desc = "";
+        let fullName = "";
+        if (hasVariables) {
+            desc = vars.description;
+            fullName = vars.name;
         }
         else {
-            mcpServers.forEach(async (s) => await s.stop());
-            await query(program);
+            throw new Error(`user command ${feat.name}: provide a name and description`);
         }
+        //console.log("F", feat);
+        // @ts-ignore
+        const cmd = program.command(fullName)
+            .description(desc)
+            .action(async (...args) => {
+            const ca = parseCommandArgs(args);
+            const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+            const c = await readCmd(feat.name, cmdPath);
+            if (!c) {
+                runtimeDataError(`can not import command ${feat.name}`);
+                throw new Error();
+            }
+            await c.run(ca.args, ca.options);
+        });
+        if (hasVariables) {
+            if (vars?.options) {
+                for (const opt of vars.options) {
+                    if (Array.isArray(opt)) {
+                        cmd.addOption(new Option(opt[0], opt[1]));
+                    }
+                    else {
+                        // predefined option
+                        switch (opt) {
+                            case "all":
+                                allOptions.forEach(o => cmd.addOption(o));
+                                break;
+                            case "display":
+                                displayOptions.forEach(o => cmd.addOption(o));
+                                break;
+                            case "inference":
+                                inferenceOptions.forEach(o => cmd.addOption(o));
+                                break;
+                            case "io":
+                                ioOptions.forEach(o => cmd.addOption(o));
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        usrCmds.push(cmd);
+    }
+    //console.log("USRCMDS", usrCmds.map(c => c.name()))
+    return usrCmds;
+}
+async function resetDbCmd() {
+    if (runMode.value == "cli") {
+        console.log("This command can not be run in cli mode");
+        return;
     }
-    //console.log("CHAT HIST", agent.history);
-    //options.history = undefined;
-    //console.log("RUN W PROMPT", prompt);
-    await agent.run(prompt, chatInferenceParams, options, chatTemplate ? chatTemplate : undefined);
-    console.log();
-    await chat(program, options, agent, mcpServers);
+    utils.deleteFileIfExists(conf.dbPath);
+    console.log("Config database reset ok. Run the conf command to recreate it");
 }
-async function buildCmds() {
-    //program.allowUnknownOption(true);
-    //const perf = usePerfTimer();
-    initBaseCommands(program);
-    //perf.measure("initBaseCommands");
-    const aliases = readAliases();
-    //perf.measure("readAliases");
-    const feats = readFeatures();
-    //perf.measure("readFeatures");
-    initCommandsFromAliases(program, aliases, feats);
-    //perf.measure("initCommandsFromAliases");
-    await initUserCmds(feats.cmd, program);
-    //perf.measure("initUserCmds");
-    //perf.measure("cmds for each");
-    //perf.final("buildCmds");
-    return program;
+async function recreateDbCmd() {
+    if (runMode.value == "cli") {
+        console.log("This command can not be run in cli mode");
+        return;
+    }
+    await conf.recreateDbFromConf();
+}
+async function processAgentsCmd(args, options) {
+    if (options?.conf) {
+        if (!state.isAgentSettingsInitialized.value) {
+            state.initAgentSettings();
+        }
+        //console.log("PTS", tasksSettings);
+        console.log(YAML.stringify({ "agents": state.agentSettings }));
+    }
+    else {
+        const ts = Object.keys(db.readFeaturesType("agent")).sort();
+        console.table(ts);
+    }
 }
-/*async function buildCmds(): Promise<Command> {
-    // Performance measurement start
-    const startTime = process.hrtime.bigint();
-    const measurements: { name: string; time: number; percentage: number }[] = [];
-    let lastTime = startTime;
-
-    function measureFunction(name: string) {
-        const currentTime = process.hrtime.bigint();
-        const elapsedNs = Number(currentTime - lastTime);
-        const elapsedSec = elapsedNs / 1_000_000_000;
-        measurements.push({ name, time: elapsedSec, percentage: 0 });
-        lastTime = currentTime;
+async function processAgentCmd(args, options) {
+    //console.log("TASK OPTS", options);
+    if (args.length == 0) {
+        console.warn("Provide an agent name");
+        return;
+    }
+    const { found, path } = getFeatureSpec(args[0], "agent");
+    if (!found) {
+        console.warn(`Agent ${args[0]} not found`);
+        return;
+    }
+    if (options?.reset) {
+        db.deleteAgentSetting(args[0]);
+        console.log("Agent", args[0], "reset ok");
+        return;
+    }
+    //console.log("RT", path)
+    const res = utils.readAgent(path);
+    if (!res.found) {
+        throw new Error(`Agent ${args[0]}, ${path} not found`);
+    }
+    //const ts = JSON.parse(res.ymlAgent);
+    console.log(res.ymlAgent);
+    if (Object.keys(options).length > 0) {
+        db.upsertAgentSettings(args[0], options);
+    }
+    const s = db.readAgentSetting(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);
     }
-
-    //program.allowUnknownOption(true);
-    measureFunction("start");
-    initBaseCommands(program);
-
-    measureFunction("initBaseCommands");
-    const aliases = readAliases();
-
-    measureFunction("readAliases");
-    const feats = readFeatures();
-
-    measureFunction("readFeatures");
-    initCommandsFromAliases(program, aliases, feats);
-
-    measureFunction("initCommandsFromAliases");
-    const cmds = await initUserCmds(feats.cmd);
-
-    measureFunction("initUserCmds");
-    cmds.forEach(c => {
-        //console.log("Add cmd", c.name());
-        program.addCommand(c)
-    });
-    measureFunction("cmds.forEach");
-
-    // Calculate percentages and display results
-    const totalTime = Number(process.hrtime.bigint() - startTime) / 1_000_000_000;
-    measurements.forEach(m => {
-        m.percentage = (m.time / totalTime) * 100;
-    });
-
-    console.log("\nPerformance Measurements for buildCmds:");
-    measurements.forEach(m => {
-        console.log(`${m.name}: ${m.time.toFixed(6)}s (${m.percentage.toFixed(2)}%)`);
-    });
-    console.log(`Total time: ${totalTime.toFixed(6)}s\n`);
-
-    return program
-}*/
-async function parseCmd(program) {
-    program.name('Agent Smith terminal client');
-    program.description('Terminal agents toolkit');
-    await program.parseAsync();
-    //console.log("CMD END");
-    //exit(0)
-    /*if (isChatMode.value) {
-        await chat(program)
-    }*/
+    //console.log(JSON.stringify(ts, null, "  "));
 }
-export { buildCmds, chat, parseCmd, program };
+export { initUserCmds, processAgentCmd, processAgentsCmd, resetDbCmd, recreateDbCmd, };

package/dist/cmd/features.d.ts

@@ -0,0 +1,6 @@
+import type { InferenceResult } from "@agent-smith/types";
+declare function executeWorkflowCmd(name: string, wargs: Array<any>): Promise<any>;
+declare function executeTaskCmd(name: string, targs?: Array<any>): Promise<InferenceResult>;
+declare function executeAgentCmd(name: string, targs?: Array<any>): Promise<InferenceResult>;
+declare function executeActionCmd(name: string, aargs: Array<any>, quiet?: boolean): Promise<any>;
+export { executeWorkflowCmd, executeTaskCmd, executeActionCmd, executeAgentCmd, };

package/dist/cmd/features.js

@@ -0,0 +1,57 @@
+import { executeAction, executeWorkflow, getAgentPrompt, getInputFromOptions, useAgentExecutor } from "@agent-smith/core";
+import { confirmToolUsage, parseCommandArgs } from "../utils.js";
+import { useInferenceCallbacks } from "./callbacks.js";
+import { chat } from "./build.js";
+async function executeWorkflowCmd(name, wargs) {
+    //console.log("WF INITIAL ARGS", typeof wargs, wargs.slice(0, -1));
+    const { args, options } = parseCommandArgs(wargs);
+    //console.log("WF ARGS", typeof args, args);
+    //console.log("WF OPTS", options);
+    return await executeWorkflow(name, args, options);
+}
+async function executeTaskCmd(name, targs = []) {
+    const ca = parseCommandArgs(targs);
+    //console.log("ARGS", ca);
+    const inferenceCallbacks = useInferenceCallbacks(name, ca.options);
+    const options = { ...ca.options, ...inferenceCallbacks };
+    const prompt = await getAgentPrompt(name, ca.args, options);
+    const tsk = await useAgentExecutor(name, { prompt: prompt }, options);
+    const tr = await tsk.execute();
+    //console.log("TR", tr);
+    if (ca?.options.chat) {
+        await chat(options, tsk.agent, tsk.mcpServers);
+    }
+    return tr;
+}
+async function executeAgentCmd(name, targs = []) {
+    //console.log("EXEC AGENT", name);
+    const ca = parseCommandArgs(targs);
+    ca.options.isAgent = true;
+    ca.options.confirmToolUsage = confirmToolUsage;
+    const inferenceCallbacks = useInferenceCallbacks(name, ca.options);
+    const options = { ...ca.options, ...inferenceCallbacks };
+    const prompt = await getAgentPrompt(name, ca.args, options);
+    const tsk = await useAgentExecutor(name, { prompt: prompt }, options);
+    //console.log("CA", ca);
+    const tr = await tsk.execute();
+    //console.dir(tsk.agent.history, { depth: 6 });
+    if (ca?.options.chat) {
+        await chat(options, tsk.agent, tsk.mcpServers);
+    }
+    return tr;
+}
+async function executeActionCmd(name, aargs, quiet = false) {
+    //console.log("AARGs", aargs)
+    const { args, options } = parseCommandArgs(aargs);
+    //console.log("CMDA", args)
+    const params = args;
+    const ip = await getInputFromOptions(options);
+    if (ip !== null) {
+        params.push(ip);
+    }
+    if (options?.debug) {
+        console.log("Action", name, "params", params);
+    }
+    return await executeAction(name, params, options, quiet);
+}
+export { executeWorkflowCmd, executeTaskCmd, executeActionCmd, executeAgentCmd, };

package/dist/cmd/{sys/read_cmds.d.ts → read_cmds.d.ts}

@@ -1,4 +1,4 @@
-import type { UserCmdDef } from "../../interfaces.js";
+import type { UserCmdDef } from "@agent-smith/types";
 declare function readCmd(name: string, cmdPath: string): Promise<UserCmdDef | null>;
 declare function readUserCmd(name: string, cmdPath: string): Promise<{
     found: boolean;

package/dist/cmd/{sys/read_cmds.js → read_cmds.js}

@@ -1,5 +1,5 @@
 import { pathToFileURL } from 'url';
-import { runtimeWarning } from "../lib/user_msgs.js";
+import { runtimeWarning } from "../user_msgs.js";
 async function readCmd(name, cmdPath) {
     const url = pathToFileURL(cmdPath).href;
     let _cmd;

package/dist/cmd/user_cmds.d.ts

@@ -0,0 +1,3 @@
+import type { Features } from "@agent-smith/types";
+declare function getUserCmdsData(feats: Features): Promise<Features>;
+export { getUserCmdsData, };

package/dist/cmd/user_cmds.js

@@ -0,0 +1,23 @@
+import path from "path";
+import { readUserCmd } from "./read_cmds.js";
+async function getUserCmdsData(feats) {
+    for (const feat of feats.cmd) {
+        const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+        const { found, userCmd } = await readUserCmd(feat.name, cmdPath);
+        console.log("USR CMD", userCmd);
+        if (found) {
+            feat.variables = {
+                description: userCmd.description,
+                name: userCmd.name,
+            };
+            if (userCmd?.options) {
+                feat.variables.options = userCmd.options;
+            }
+        }
+        else {
+            throw new Error(`user command ${feat.name} not found at ${cmdPath}`);
+        }
+    }
+    return feats;
+}
+export { getUserCmdsData, };

package/dist/index.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import { argv } from 'process';
 import { query } from "./cli.js";
-import { resetDbCmd } from './cmd/clicmds/cmds.js';
-import { updateConfCmd } from './cmd/clicmds/updateconf.js';
-import { buildCmds, parseCmd } from './cmd/cmds.js';
-import { formatMode, init, inputMode, isChatMode, outputMode, runMode } from './state/state.js';
-//import { usePerfTimer } from './main.js';
+import { resetDbCmd } from './cmd/cmds.js';
+import { state, conf } from "@agent-smith/core";
+import { isChatMode, runMode } from './state.js';
+import { buildCmds, parseCmd } from './cmd/build.js';
 async function main() {
     //const perf = usePerfTimer();
     const nargs = argv.length;
@@ -14,7 +13,7 @@ async function main() {
     }
     else if (nargs >= 3) {
         if (argv[2] == "conf") {
-            await updateConfCmd(argv.slice(-1));
+            await conf.updateConfCmd(argv.slice(-1));
             return;
         }
         else if (argv[2] == "reset") {
@@ -23,11 +22,12 @@ async function main() {
         }
     }
     //perf.measure("base");
-    await init();
+    await state.init();
     //perf.measure("init");
     const program = await buildCmds();
     //perf.measure("buildCmds");
     //perf.final("index start");
+    // @ts-ignore
     program.hook('preAction', async (thisCommand, actionCommand) => {
         const options = actionCommand.opts();
         //console.log("POPTS", options)
@@ -36,16 +36,16 @@ async function main() {
             isChatMode.value = true;
         }
         if (options?.clipboardInput !== undefined) {
-            inputMode.value = "clipboard";
+            state.inputMode.value = "clipboard";
         }
         if (options?.inputFile !== undefined) {
-            inputMode.value = "promptfile";
+            state.inputMode.value = "promptfile";
         }
         if (options?.markdownOutput !== undefined) {
-            formatMode.value = "markdown";
+            state.formatMode.value = "markdown";
         }
         if (options?.clipboardOutput !== undefined) {
-            outputMode.value = "clipboard";
+            state.outputMode.value = "clipboard";
         }
     });
     switch (runMode.value) {

package/dist/main.d.ts

@@ -1,38 +1,3 @@
-import { updateConfCmd } from "./cmd/clicmds/updateconf.js";
-import { executeAction } from "./cmd/lib/actions/cmd.js";
-import { McpClient } from "./cmd/lib/mcp.js";
-import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
-import { executeTask } from "./cmd/lib/tasks/cmd.js";
-import { readTask } from "./cmd/lib/tasks/read.js";
-import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
-import { extractToolDoc } from "./cmd/lib/tools.js";
-import { executeWorkflow } from "./cmd/lib/workflows/cmd.js";
-import { readWorkflow } from "./cmd/lib/workflows/read.js";
-import { allOptions, displayOptions, inferenceOptions, ioOptions } from "./cmd/options.js";
-import { writeToClipboard } from "./cmd/sys/clipboard.js";
-import { execute, run } from "./cmd/sys/execute.js";
-import { readConf } from "./cmd/sys/read_conf.js";
-import { createConfigFile, getConfigPath, processConfPath, updateConfigFile } from "./conf.js";
-import { initDb } from "./db/db.js";
-import { readBackends, readFeaturesType, readFilePaths, readTool } from "./db/read.js";
-import { upsertTaskSettings } from "./db/write.js";
-import { FeatureType, TaskSettings } from "./interfaces.js";
-import { backend, setBackend } from "./state/backends.js";
-import { init, initState, isStateReady, pluginDataDir } from "./state/state.js";
-import { getTaskSettings } from "./state/tasks.js";
-import { usePerfTimer } from "./utils/perf.js";
-import { extractBetweenTags, splitThinking } from "./utils/text.js";
-declare const db: {
-    init: typeof initDb;
-    readFilePaths: typeof readFilePaths;
-    readFeaturesType: typeof readFeaturesType;
-    readTool: typeof readTool;
-    getTaskSettings: typeof getTaskSettings;
-    upsertTaskSettings: typeof upsertTaskSettings;
-    readBackends: typeof readBackends;
-};
-declare const fs: {
-    openTaskSpec: typeof openTaskSpec;
-    readWorkflow: typeof readWorkflow;
-};
-export { allOptions, backend, createConfigFile, db, displayOptions, execute, executeAction, executeTask, executeWorkflow, extractBetweenTags, extractToolDoc, FeatureType, fs, getConfigPath, inferenceOptions, init, initState, ioOptions, isStateReady, McpClient, openTaskSpec, parseCommandArgs, pluginDataDir, processConfPath, readConf, readTask, run, setBackend, splitThinking, TaskSettings, updateConfCmd, updateConfigFile, usePerfTimer, writeToClipboard, };
+import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./options.js";
+import { parseCommandArgs } from "./utils.js";
+export { displayOptions, ioOptions, inferenceOptions, allOptions, parseCommandArgs, };

package/dist/main.js

@@ -1,37 +1,3 @@
-import { updateConfCmd } from "./cmd/clicmds/updateconf.js";
-import { executeAction } from "./cmd/lib/actions/cmd.js";
-import { McpClient } from "./cmd/lib/mcp.js";
-import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
-import { executeTask } from "./cmd/lib/tasks/cmd.js";
-import { readTask } from "./cmd/lib/tasks/read.js";
-import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
-import { extractToolDoc } from "./cmd/lib/tools.js";
-import { executeWorkflow } from "./cmd/lib/workflows/cmd.js";
-import { readWorkflow } from "./cmd/lib/workflows/read.js";
-import { allOptions, displayOptions, inferenceOptions, ioOptions } from "./cmd/options.js";
-import { writeToClipboard } from "./cmd/sys/clipboard.js";
-import { execute, run } from "./cmd/sys/execute.js";
-import { readConf } from "./cmd/sys/read_conf.js";
-import { createConfigFile, getConfigPath, processConfPath, updateConfigFile } from "./conf.js";
-import { initDb } from "./db/db.js";
-import { readBackends, readFeaturesType, readFilePaths, readTool } from "./db/read.js";
-import { upsertTaskSettings } from "./db/write.js";
-import { backend, setBackend } from "./state/backends.js";
-import { init, initState, isStateReady, pluginDataDir } from "./state/state.js";
-import { getTaskSettings } from "./state/tasks.js";
-import { usePerfTimer } from "./utils/perf.js";
-import { extractBetweenTags, splitThinking } from "./utils/text.js";
-const db = {
-    init: initDb,
-    readFilePaths,
-    readFeaturesType,
-    readTool,
-    getTaskSettings,
-    upsertTaskSettings,
-    readBackends,
-};
-const fs = {
-    openTaskSpec,
-    readWorkflow,
-};
-export { allOptions, backend, createConfigFile, db, displayOptions, execute, executeAction, executeTask, executeWorkflow, extractBetweenTags, extractToolDoc, fs, getConfigPath, inferenceOptions, init, initState, ioOptions, isStateReady, McpClient, openTaskSpec, parseCommandArgs, pluginDataDir, processConfPath, readConf, readTask, run, setBackend, splitThinking, updateConfCmd, updateConfigFile, usePerfTimer, writeToClipboard, };
+import { displayOptions, ioOptions, inferenceOptions, allOptions, } from "./options.js";
+import { parseCommandArgs } from "./utils.js";
+export { displayOptions, ioOptions, inferenceOptions, allOptions, parseCommandArgs, };

package/dist/state.d.ts

@@ -0,0 +1,6 @@
+import type { InferenceParams, RunMode } from "@agent-smith/types";
+declare let chatInferenceParams: InferenceParams;
+declare const isChatMode: import("@vue/reactivity").Ref<boolean, boolean>;
+declare const runMode: import("@vue/reactivity").Ref<RunMode, RunMode>;
+declare function setChatInferenceParams(ip: InferenceParams): void;
+export { runMode, isChatMode, chatInferenceParams, setChatInferenceParams, };

package/dist/state.js

@@ -0,0 +1,8 @@
+import { ref } from "@vue/reactivity";
+let chatInferenceParams = { temperature: 0.2, min_p: 0.05, max_tokens: 2048 };
+const isChatMode = ref(false);
+const runMode = ref("cmd");
+function setChatInferenceParams(ip) {
+    chatInferenceParams = ip;
+}
+export { runMode, isChatMode, chatInferenceParams, setChatInferenceParams, };

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCallSpec } from '@agent-smith/types';
+declare function parseCommandArgs(args: Array<any>): {
+    args: Array<string>;
+    options: Record<string, any>;
+};
+declare function confirmToolUsage(toolCall: ToolCallSpec): Promise<boolean>;
+declare const printToken: (t: string, showTokens?: boolean, dim?: boolean) => void;
+export { parseCommandArgs, confirmToolUsage, printToken, };