@agent-smith/cli 0.0.63 → 0.0.64

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

@@ -1,41 +1,30 @@
-import { isDebug, isVerbose } from "../../../state/state.js";
+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 { readWorkflow } from "./read.js";
-import { executeTaskCmd } from "../tasks/cmd.js";
-import { executeActionCmd } from "../actions/cmd.js";
-import { executeAdaptaterCmd } from "../adaptaters/cmd.js";
-async function executeWorkflowCmd(name, args = [], options = {}) {
+async function executeWorkflow(name, params, options) {
     const { workflow, found } = await readWorkflow(name);
     if (!found) {
         throw new Error(`Workflow ${name} not found`);
     }
+    const isDebug = options?.debug === true;
+    const isVerbose = options?.verbose === true;
     const stepNames = Object.keys(workflow);
-    if (isDebug.value || isVerbose.value) {
+    if (isDebug || isVerbose) {
         console.log("Running workflow", name, stepNames.length, "steps");
     }
-    let params = Array.isArray(args) ? {} : args;
     let i = 0;
     const finalTaskIndex = stepNames.length + 1;
-    let taskRes = {};
+    let taskRes = params;
     for (const [name, step] of Object.entries(workflow)) {
-        if (isDebug.value || isVerbose.value) {
+        if (isDebug || isVerbose) {
             console.log(`${i + 1}: ${step.type} ${name}`);
         }
-        let pval = new Array();
-        if (i == 0) {
-            pval = [name, ...args];
-        }
-        else {
-            if (Array.isArray(params)) {
-                pval = [name, ...params];
-            }
-            else {
-                pval = { name: name, ...params };
-            }
-        }
         switch (step.type) {
             case "task":
                 try {
-                    const tr = await executeTaskCmd(pval, options);
+                    const tr = await executeTask(name, taskRes, options, true);
                     taskRes = tr;
                 }
                 catch (e) {
@@ -44,9 +33,9 @@ async function executeWorkflowCmd(name, args = [], options = {}) {
                 break;
             case "action":
                 try {
-                    const ares = await executeActionCmd(pval, options, true);
+                    const ares = await executeAction(name, taskRes, options, true);
                     if (typeof ares == "string") {
-                        taskRes = [ares];
+                        taskRes = { payload: ares };
                     }
                     else {
                         taskRes = ares;
@@ -61,9 +50,9 @@ async function executeWorkflowCmd(name, args = [], options = {}) {
                 break;
             case "adaptater":
                 try {
-                    const ares = await executeAdaptaterCmd(pval, options);
+                    const ares = await executeAdaptater(name, taskRes, options);
                     if (typeof ares == "string") {
-                        taskRes = [ares];
+                        taskRes = { payload: ares };
                     }
                     else {
                         taskRes = ares;
@@ -81,4 +70,9 @@ async function executeWorkflowCmd(name, args = [], options = {}) {
     }
     return taskRes;
 }
-export { executeWorkflowCmd, };
+async function executeWorkflowCmd(name, wargs) {
+    const { args, options } = parseCommandArgs(wargs);
+    const params = { args: args };
+    return await executeWorkflow(name, params, options);
+}
+export { executeWorkflow, executeWorkflowCmd, };

package/dist/cmd/options.d.ts

@@ -0,0 +1,8 @@
+import { Option } from "commander";
+declare const displayOptions: Array<Option>;
+declare const inferenceOptions: Array<Option>;
+declare const ioOptions: Array<Option>;
+declare const taskOptions: Array<Option>;
+declare const actionOptions: Array<Option>;
+declare const workflowOptions: Array<Option>;
+export { displayOptions, ioOptions, inferenceOptions, taskOptions, actionOptions, workflowOptions, };

package/dist/cmd/options.js

@@ -0,0 +1,62 @@
+import { InvalidArgumentError, Option } from "commander";
+const displayOptions = [
+    new Option("-v, --verbose", "use the verbose mode"),
+    new Option("-d, --debug", "use the debug mode"),
+];
+const inferenceOptions = [
+    new Option("-m, --model <name>", "the model name").argParser(parseString),
+    new Option("-x, --ctx", "context window size").argParser(parseIntValue),
+    new Option("--tpl, --template <template>", "the template to use"),
+    new Option("--mt, --max_tokens <number>", "the number of predictions to return").argParser(parseIntValue),
+    new Option("-k, --top_k <number>", "limits the result set to the top K results").argParser(parseIntValue),
+    new Option("-p, --top_p <number>", "filters results based on cumulative probability").argParser(parseFloatValue),
+    new Option("--mp, --min_p <number>", "the minimum probability for a token to be considered, relative to the probability of the most likely token").argParser(parseFloatValue),
+    new Option("-t, --temperature <number>", "adjusts randomness in sampling; higher values mean more randomness").argParser(parseFloatValue),
+    new Option("-r, --repeat_penalty <number>", "adjusts penalty for repeated tokens").argParser(parseFloatValue),
+];
+const ioOptions = [
+    new Option("--if, --input-file", "use promptfile input mode"),
+    new Option("--ic, --clipboard-input", "use clipboard input mode"),
+    new Option("--im, --manual-input", "use manual input mode (default)"),
+    new Option("--oc, --clipboard-output", "use clipboard output mode"),
+    new Option("--omd, --markdown-output", "use markdown output"),
+    new Option("--otxt, --text-output", "use text output (default)"),
+];
+const taskOptions = [
+    ...displayOptions,
+    ...ioOptions,
+    ...inferenceOptions,
+    new Option("--tokens", "toggle show tokens mode"),
+    new Option("-c, --chat", "toggle chat mode for tasks"),
+];
+const actionOptions = [
+    ...displayOptions,
+    ...ioOptions,
+];
+const workflowOptions = [
+    ...taskOptions
+];
+function parseString(value) {
+    if (typeof value !== 'string')
+        throw new InvalidArgumentError('The value must be a string');
+    return value;
+}
+function parseIntValue(value) {
+    if (typeof value !== 'string')
+        throw new InvalidArgumentError('The value must be a string');
+    const num = parseInt(value);
+    if (!isNaN(num))
+        return num;
+    else
+        throw new InvalidArgumentError(`Invalid integer: ${value}`);
+}
+function parseFloatValue(value) {
+    if (typeof value !== 'string')
+        throw new InvalidArgumentError('The value must be a string');
+    const num = parseFloat(value);
+    if (!isNaN(num))
+        return num;
+    else
+        throw new InvalidArgumentError(`Invalid float: ${value}`);
+}
+export { displayOptions, ioOptions, inferenceOptions, taskOptions, actionOptions, workflowOptions, };

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

@@ -1,3 +1,3 @@
-import { Cmd } from "../../interfaces.js";
-declare function readCmds(dir: string): Promise<Record<string, Cmd>>;
+import { Command } from "commander";
+declare function readCmds(dir: string): Promise<Array<Command>>;
 export { readCmds };

package/dist/cmd/sys/read_cmds.js

@@ -15,14 +15,14 @@ function _readCmdsDir(dir) {
     return fileNames;
 }
 async function readCmds(dir) {
-    const cmds = {};
+    const cmds = new Array();
     const fileNames = _readCmdsDir(dir);
     for (const name of fileNames) {
         const { cmd } = await import(path.join(dir, name + ".js"));
         if (!cmd) {
             throw new Error(`command ${name} not found in ${dir}`);
         }
-        cmds[name] = cmd;
+        cmds.push(cmd);
     }
     return cmds;
 }

package/dist/db/db.d.ts

@@ -1,5 +1,5 @@
 import { Database } from "better-sqlite3";
 declare const dbPath: string;
 declare let db: Database;
-declare function initDb(isVerbose: boolean, execSchema?: boolean): void;
+declare function initDb(isVerbose: boolean, execSchema: boolean): void;
 export { db, dbPath, initDb, };

package/dist/db/db.js

@@ -5,10 +5,11 @@ import { createDirectoryIfNotExists } from "../cmd/sys/dirs.js";
 const confDir = path.join(process.env.HOME ?? "~/", ".config/agent-smith/cli");
 const dbPath = path.join(confDir, "config.db");
 let db;
-function initDb(isVerbose, execSchema = false) {
+const debugDb = true;
+function initDb(isVerbose, execSchema) {
     if (execSchema) {
         createDirectoryIfNotExists(confDir, true);
-        db = new DatabaseConstructor(dbPath, { fileMustExist: false });
+        db = new DatabaseConstructor(dbPath, { fileMustExist: false, verbose: debugDb ? console.log : undefined });
         schemas.forEach((s) => {
             db.exec(s);
             if (isVerbose) {

package/dist/db/read.d.ts

@@ -2,7 +2,8 @@ import { ToolSpec } from "modprompt";
 import { AliasType, FeatureSpec, FeatureType, DbModelDef, ToolType } from "../interfaces.js";
 declare function readFeaturePaths(): Array<string>;
 declare function readPlugins(): Array<Record<string, string>>;
-declare function readFeatures(): Record<FeatureType, Record<string, string>>;
+declare function readFeaturesType(type: FeatureType): Record<string, FeatureSpec>;
+declare function readFeatures(): Record<FeatureType, Record<string, FeatureSpec>>;
 declare function readAliases(): Array<{
     name: string;
     type: AliasType;
@@ -30,4 +31,4 @@ declare function readModel(shortname: string): {
     found: boolean;
     modelData: Record<string, any>;
 };
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, };

package/dist/db/read.js

@@ -17,25 +17,31 @@ function readPlugins() {
     });
     return f;
 }
-function _readFeaturesType(type) {
-    const stmt = db.prepare(`SELECT name, path FROM ${type}`);
+function readFeaturesType(type) {
+    const stmt = db.prepare(`SELECT name, path, ext, variables FROM ${type}`);
     const data = stmt.all();
-    let f = {};
+    const res = {};
     data.forEach((row) => {
-        f[row.name] = row.path;
+        const vars = row?.variables ? JSON.parse(row.variables) : undefined;
+        res[row.name] = {
+            name: row.name,
+            path: row.path,
+            ext: row.ext,
+            variables: vars,
+        };
     });
-    return f;
+    return res;
 }
 function readFeatures() {
     const feats = {
         task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}, modelfile: {}
     };
-    feats.task = _readFeaturesType("task");
-    feats.action = _readFeaturesType("action");
-    feats.cmd = _readFeaturesType("cmd");
-    feats.workflow = _readFeaturesType("workflow");
-    feats.adaptater = _readFeaturesType("adaptater");
-    feats.modelfile = _readFeaturesType("modelfile");
+    feats.task = readFeaturesType("task");
+    feats.action = readFeaturesType("action");
+    feats.cmd = readFeaturesType("cmd");
+    feats.workflow = readFeaturesType("workflow");
+    feats.adaptater = readFeaturesType("adaptater");
+    feats.modelfile = readFeaturesType("modelfile");
     return feats;
 }
 function readAliases() {
@@ -129,4 +135,4 @@ function readModel(shortname) {
     }
     return { found: false, modelData: {} };
 }
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, };

package/dist/db/schemas.js

@@ -16,38 +16,43 @@ const tasks = `CREATE TABLE IF NOT EXISTS task (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
+    variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
 const workflow = `CREATE TABLE IF NOT EXISTS workflow (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
+    variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
 const action = `CREATE TABLE IF NOT EXISTS action (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
+    variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
 );`;
 const adaptater = `CREATE TABLE IF NOT EXISTS adaptater (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
+    variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
 );`;
-const tool = `CREATE TABLE IF NOT EXISTS tool (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT UNIQUE NOT NULL,
-    spec TEXT NOT NULL,
-    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
-);`;
 const cmd = `CREATE TABLE IF NOT EXISTS cmd (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
+    variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('js') )
 );`;
+const tool = `CREATE TABLE IF NOT EXISTS tool (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    spec TEXT NOT NULL,
+    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
+);`;
 const alias = `CREATE TABLE IF NOT EXISTS aliases (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
@@ -57,6 +62,7 @@ const modelfile = `CREATE TABLE IF NOT EXISTS modelfile (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
+    variables TEXT,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
 const model = `CREATE TABLE IF NOT EXISTS model (

package/dist/db/write.js

@@ -1,4 +1,4 @@
-import { extractToolDoc } from "../cmd/lib/tools.js";
+import { extractTaskToolDocAndVariables, extractToolDoc } from "../cmd/lib/tools.js";
 import { db } from "./db.js";
 import { readModels } from "./read.js";
 function updatePromptfilePath(pf) {
@@ -101,15 +101,29 @@ function upsertAndCleanFeatures(feats, type) {
     });
     return newFeatures;
 }
+function updateVariables(name, variableDoc) {
+    const stmt1 = db.prepare("SELECT id FROM task WHERE name = ?");
+    const result = stmt1.get(name);
+    if (!result?.id) {
+        return;
+    }
+    const updateStmt = db.prepare("UPDATE task SET variables = ? WHERE id = ?");
+    updateStmt.run(variableDoc, result.id);
+    console.log("~", "[task variables] updated for", name);
+}
 function upsertTool(name, type, toolDoc) {
     const stmt1 = db.prepare("SELECT * FROM tool WHERE name = ?");
     const result = stmt1.get(name);
     if (result?.id) {
-        return;
+        const updateStmt = db.prepare("UPDATE tool SET spec = ?, type = ? WHERE id = ?");
+        updateStmt.run(toolDoc, type, result.id);
+        console.log("~", "[tool] updated from", type, ":", name);
+    }
+    else {
+        const stmt = db.prepare("INSERT INTO tool (name, spec, type) VALUES (?,?,?)");
+        stmt.run(name, toolDoc, type);
+        console.log("+", "[tool] added from", type, ":", name);
     }
-    const stmt = db.prepare("INSERT INTO tool (name, spec, type) VALUES (?,?,?)");
-    stmt.run(name, toolDoc, type);
-    console.log("+", "[tool] from", type, ":", name);
 }
 function updateModels(models) {
     const allDbModels = readModels();
@@ -137,22 +151,25 @@ function updateModels(models) {
     })();
 }
 function updateFeatures(feats) {
-    const newTasks = upsertAndCleanFeatures(feats.task, "task");
-    newTasks.forEach((feat) => {
-        const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
-        if (found) {
+    upsertAndCleanFeatures(feats.task, "task");
+    feats.task.forEach((feat) => {
+        const { toolDoc, variables } = extractTaskToolDocAndVariables(feat.name, feat.ext, feat.path);
+        if (toolDoc.length > 0) {
             upsertTool(feat.name, "task", toolDoc);
         }
+        if (variables.required.length > 0 || variables.optional.length > 0) {
+            updateVariables(feat.name, JSON.stringify(variables, null, "  "));
+        }
     });
-    const newActions = upsertAndCleanFeatures(feats.action, "action");
-    newActions.forEach((feat) => {
+    upsertAndCleanFeatures(feats.action, "action");
+    feats.action.forEach((feat) => {
         const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
         if (found) {
             upsertTool(feat.name, "action", toolDoc);
         }
     });
-    const newWorkflows = upsertAndCleanFeatures(feats.workflow, "workflow");
-    newWorkflows.forEach((feat) => {
+    upsertAndCleanFeatures(feats.workflow, "workflow");
+    feats.workflow.forEach((feat) => {
         const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
         if (found) {
             upsertTool(feat.name, "workflow", toolDoc);

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { argv } from 'process';
-import { query } from "./cli.js";
-import { initState, runMode } from './state/state.js';
 import { initAgent } from './agent.js';
-import { initCliCmds, parseCmd } from './cmd/cmds.js';
-import { updateConfCmd } from './cmd/clicmds/cmds.js';
+import { query } from "./cli.js";
+import { buildCmds, parseCmd } from './cmd/cmds.js';
+import { initState, isChatMode, runMode } from './state/state.js';
+import { updateConfCmd } from './cmd/clicmds/update.js';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {
@@ -12,19 +12,25 @@ async function main() {
     }
     else if (nargs >= 3) {
         if (argv[2] == "conf") {
-            await updateConfCmd(argv.slice(-1), {});
+            await updateConfCmd(argv.slice(-1));
             return;
         }
     }
     await initState();
     await initAgent();
+    const program = await buildCmds();
+    program.hook('preAction', async (thisCommand, actionCommand) => {
+        const options = actionCommand.opts();
+        if (options?.chat === true) {
+            isChatMode.value = true;
+        }
+    });
     switch (runMode.value) {
         case "cli":
-            await initCliCmds();
-            await query();
+            await query(program);
             break;
         default:
-            await parseCmd();
+            await parseCmd(program);
             break;
     }
 }

package/dist/interfaces.d.ts

@@ -1,15 +1,15 @@
 import { BaseLmTask, ModelSpec } from "@agent-smith/lmtask";
 import { InferenceParams } from "@locallm/types";
-interface Cmd {
-    cmd: CmdExecutor;
-    description: string;
-    args?: string;
+interface FeatureVariables {
+    required: Array<string>;
+    optional: Array<string>;
 }
 interface FeatureSpec {
     id?: number;
     name: string;
     path: string;
     ext: FeatureExtension;
+    variables?: FeatureVariables;
 }
 interface Features {
     task: Array<{
@@ -92,7 +92,6 @@ interface FinalLmTaskConfig {
     model?: ModelSpec;
     modelname?: string;
 }
-type CmdExecutor = (args: Array<string>, options: any) => Promise<any>;
 type InputMode = "manual" | "promptfile" | "clipboard";
 type OutputMode = "txt" | "clipboard";
 type RunMode = "cli" | "cmd";
@@ -108,4 +107,4 @@ type CmdExtension = "js";
 type ModelFileExtension = "yml";
 type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension | ModelFileExtension;
 type AliasType = "task" | "action" | "workflow";
-export { Cmd, CmdExecutor, InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, ModelFileExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, };
+export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, ModelFileExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, };

package/dist/main.d.ts

@@ -1,15 +1,15 @@
 import { execute, run } from "./cmd/sys/execute.js";
-import { executeActionCmd } from "./cmd/lib/actions/cmd.js";
-import { executeTaskCmd } from "./cmd/lib/tasks/cmd.js";
-import { executeWorkflowCmd } from "./cmd/lib/workflows/cmd.js";
+import { executeTask } from "./cmd/lib/tasks/cmd.js";
+import { executeAction } from "./cmd/lib/actions/cmd.js";
+import { executeWorkflow } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
-import { pingCmd } from "./cmd/clicmds/cmds.js";
 import { initAgent } from "./agent.js";
 import { initState, pluginDataDir } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
-import { parseArgs } from "./utils/args.js";
+import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
 import { LmTaskConf } from "@agent-smith/lmtask/dist/interfaces.js";
 import { extractToolDoc } from "./cmd/lib/tools.js";
 import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
 import { extractBetweenTags, splitThinking } from "./utils/text.js";
-export { execute, run, pingCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseArgs, extractToolDoc, LmTaskConf, openTaskSpec, extractBetweenTags, splitThinking, };
+import { displayOptions, ioOptions, inferenceOptions, taskOptions, actionOptions, workflowOptions } from "./cmd/options.js";
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, LmTaskConf, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, taskOptions, actionOptions, workflowOptions, };

package/dist/main.js

@@ -1,14 +1,14 @@
 import { execute, run } from "./cmd/sys/execute.js";
-import { executeActionCmd } from "./cmd/lib/actions/cmd.js";
-import { executeTaskCmd } from "./cmd/lib/tasks/cmd.js";
-import { executeWorkflowCmd } from "./cmd/lib/workflows/cmd.js";
+import { executeTask } from "./cmd/lib/tasks/cmd.js";
+import { executeAction } from "./cmd/lib/actions/cmd.js";
+import { executeWorkflow } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
-import { pingCmd } from "./cmd/clicmds/cmds.js";
 import { initAgent } from "./agent.js";
 import { initState, pluginDataDir } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
-import { parseArgs } from "./utils/args.js";
+import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
 import { extractToolDoc } from "./cmd/lib/tools.js";
 import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
 import { extractBetweenTags, splitThinking } from "./utils/text.js";
-export { execute, run, pingCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, };
+import { displayOptions, ioOptions, inferenceOptions, taskOptions, actionOptions, workflowOptions } from "./cmd/options.js";
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, taskOptions, actionOptions, workflowOptions, };

package/dist/state/state.d.ts

@@ -1,15 +1,11 @@
 import { PythonShell } from 'python-shell';
-import { InputMode, RunMode, FormatMode, OutputMode, VerbosityMode } from "../interfaces.js";
+import { InputMode, RunMode, FormatMode, OutputMode } from "../interfaces.js";
 declare let pyShell: PythonShell;
 declare const inputMode: import("@vue/reactivity").Ref<InputMode, InputMode>;
 declare const outputMode: import("@vue/reactivity").Ref<OutputMode, OutputMode>;
 declare const runMode: import("@vue/reactivity").Ref<RunMode, RunMode>;
 declare const formatMode: import("@vue/reactivity").Ref<FormatMode, FormatMode>;
 declare const isChatMode: import("@vue/reactivity").Ref<boolean, boolean>;
-declare const isDebug: import("@vue/reactivity").ComputedRef<boolean>;
-declare const isVerbose: import("@vue/reactivity").ComputedRef<boolean>;
-declare const isQuiet: import("@vue/reactivity").ComputedRef<boolean>;
-declare const isShowTokens: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const promptfilePath: import("@vue/reactivity").Ref<string, string>;
 declare const dataDirPath: import("@vue/reactivity").Ref<string, string>;
 declare const lastCmd: {
@@ -19,5 +15,4 @@ declare const lastCmd: {
 declare function initFilepaths(): void;
 declare function initState(): Promise<void>;
 declare function pluginDataDir(pluginName: string): string;
-declare function setVerbosity(mode: VerbosityMode): void;
-export { inputMode, outputMode, isChatMode, isShowTokens, runMode, formatMode, lastCmd, isDebug, isVerbose, isQuiet, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, setVerbosity, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, pyShell, };

package/dist/state/state.js

@@ -1,4 +1,4 @@
-import { computed, reactive, ref } from "@vue/reactivity";
+import { reactive, ref } from "@vue/reactivity";
 import { initDb } from "../db/db.js";
 import { readFilePaths } from "../db/read.js";
 import path from "path";
@@ -9,11 +9,6 @@ const outputMode = ref("txt");
 const runMode = ref("cmd");
 const formatMode = ref("text");
 const isChatMode = ref(false);
-const verbosity = ref("quiet");
-const isDebug = computed(() => verbosity.value == "debug");
-const isVerbose = computed(() => verbosity.value == "verbose");
-const isQuiet = computed(() => verbosity.value == "quiet");
-const isShowTokens = ref(false);
 const promptfilePath = ref("");
 const dataDirPath = ref("");
 const isStateReady = ref(false);
@@ -37,7 +32,7 @@ async function initState() {
     if (isStateReady.value) {
         return;
     }
-    initDb(isDebug.value);
+    initDb(false, false);
     initFilepaths();
     isStateReady.value = true;
 }
@@ -53,7 +48,4 @@ function pluginDataDir(pluginName) {
     createDirectoryIfNotExists(pluginDatapath);
     return pluginDatapath;
 }
-function setVerbosity(mode) {
-    verbosity.value = mode;
-}
-export { inputMode, outputMode, isChatMode, isShowTokens, runMode, formatMode, lastCmd, isDebug, isVerbose, isQuiet, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, setVerbosity, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, pyShell, };

package/dist/utils/perf.d.ts

@@ -1,6 +1,6 @@
 declare const usePerfTimer: (startTimer?: boolean) => {
     start: () => number;
-    time: () => string | number;
+    time: () => string;
     timeRaw: () => string | number;
     printTime: () => void;
 };

package/dist/utils/perf.js

@@ -16,17 +16,17 @@ const usePerfTimer = (startTimer = true) => {
         const humanizedTime = _formatDuration(duration);
         return humanizedTime;
     };
-    const time = () => _end(false);
+    const time = () => _end(false).toString();
     const printTime = () => console.log(_end(false));
     const timeRaw = () => _end(true);
     const _formatDuration = (ms) => {
-        const seconds = Math.floor(ms / 1000);
-        const minutes = Math.floor(seconds / 60);
+        const seconds = ms / 1000;
+        const minutes = seconds / 60;
         if (ms < 1000)
-            return `${ms.toFixed(2)}ms`;
+            return `${ms.toFixed(2)} milliseconds`;
         if (seconds < 60)
-            return `${seconds.toFixed(2)}s`;
-        return `${minutes}m ${seconds % 60}s`;
+            return `${seconds.toFixed(1)} seconds`;
+        return `${minutes.toFixed(1)} minutes ${seconds % 60} seconds`;
     };
     return {
         start,