@agent-smith/cli 0.0.99 → 0.0.101

package/dist/cmd/clicmds/base.js

@@ -2,7 +2,7 @@ import { Option } from "commander";
 import { listBackends, setBackend } from "../../state/backends.js";
 import { parseCommandArgs } from "../lib/options_parsers.js";
 import { processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd } from "./cmds.js";
-import { updateConfCmd } from "./update.js";
+import { updateConfCmd } from "./updateconf.js";
 import { inferenceOptions } from "../options.js";
 function initBaseCommands(program) {
     program.command("exit")

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

@@ -0,0 +1,4 @@
+import { FeatureSpec } from '../../interfaces.js';
+declare function ensureUserCmdsCacheFileExists(cacheFilePath: string): string;
+declare function updateUserCmdsCache(cacheFilePath: string, cmdFeats: Array<FeatureSpec>): void;
+export { ensureUserCmdsCacheFileExists, updateUserCmdsCache, };

package/dist/cmd/clicmds/cache.js

@@ -0,0 +1,39 @@
+import fs from 'fs';
+import path from 'path';
+import { runtimeError } from '../../utils/user_msgs.js';
+function createCacheFileContent(cmdFeats) {
+    const imports = new Array();
+    const cmdNames = new Array();
+    let i = 1;
+    cmdFeats.forEach(feat => {
+        const fileName = feat.name + "." + feat.ext;
+        const importPath = path.join(feat.path, fileName);
+        const cmdId = `c${i}`;
+        const line = `import { cmd as ${cmdId} } from "file://${importPath}";`;
+        imports.push(line);
+        cmdNames.push(cmdId);
+        ++i;
+    });
+    const finalImports = imports.join("\n");
+    const cmds = `const cmds = [ ${cmdNames.join(", ")} ]`;
+    const end = "export { cmds }";
+    return `${finalImports}\n\n${cmds}\n\n${end}`;
+}
+function ensureUserCmdsCacheFileExists(cacheFilePath) {
+    const fileExists = fs.existsSync(cacheFilePath);
+    if (!fileExists) {
+        fs.writeFileSync(cacheFilePath, "const cmds = [];\nexport { cmds }");
+    }
+    return cacheFilePath;
+}
+function updateUserCmdsCache(cacheFilePath, cmdFeats) {
+    const filePath = ensureUserCmdsCacheFileExists(cacheFilePath);
+    const cacheFileContent = createCacheFileContent(cmdFeats);
+    try {
+        fs.writeFileSync(filePath, cacheFileContent);
+    }
+    catch (err) {
+        runtimeError("Error writing to user commands cache file at " + filePath, `${err}`);
+    }
+}
+export { ensureUserCmdsCacheFileExists, updateUserCmdsCache, };

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

@@ -5,4 +5,4 @@ declare function resetDbCmd(): Promise<any>;
 declare function updateFeaturesCmd(): Promise<any>;
 declare function processTasksCmd(args: Array<string>, options: Record<string, any>): Promise<void>;
 declare function processTaskCmd(args: Array<string>, options: Record<string, any>): Promise<any>;
-export { initUserCmds, resetDbCmd, updateFeaturesCmd, processTaskCmd, processTasksCmd, };
+export { initUserCmds, processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd };

package/dist/cmd/clicmds/cmds.js

@@ -1,27 +1,37 @@
-import { readCmds } from "../sys/read_cmds.js";
-import YAML from 'yaml';
 import colors from "ansi-colors";
-import { dbPath } from "../../conf.js";
+import path from "path";
+import { pathToFileURL } from 'url';
+import YAML from 'yaml';
+import { cacheFilePath, dbPath } from "../../conf.js";
 import { readFeaturePaths, readFeaturesType, readTaskSetting } from "../../db/read.js";
 import { cleanupFeaturePaths, deleteTaskSetting, updateAliases, updateFeatures, upsertTaskSettings } from "../../db/write.js";
 import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
 import { readPluginsPaths } from "../../state/plugins.js";
 import { runMode } from "../../state/state.js";
+import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from '../../state/tasks.js';
+import { cmds } from "../../state/auto/usercmds.js";
 import { deleteFileIfExists } from "../sys/delete_file.js";
+import { readCmd } from "../sys/read_cmds.js";
 import { readTask } from "../sys/read_task.js";
-import { isTaskSettingsInitialized, initTaskSettings, tasksSettings } from '../../state/tasks.js';
+import { updateUserCmdsCache } from './cache.js';
 async function initUserCmds(cmdFeats) {
-    const paths = new Set();
-    const cmds = new Array();
-    for (const feat of Object.values(cmdFeats)) {
-        if (paths.has(feat.path)) {
-            continue;
+    const features = Object.values(cmdFeats);
+    if (features.length == 0) {
+        return [];
+    }
+    let endCmds = cmds;
+    if (cmds.length == 0) {
+        updateUserCmdsCache(cacheFilePath, features);
+        const url = pathToFileURL(cacheFilePath).href;
+        const usrCmds = new Array();
+        for (const feat of features) {
+            const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+            const c = await readCmd(feat.name, cmdPath);
+            usrCmds.push(c);
         }
-        const c = await readCmds(`${feat.path}`);
-        cmds.push(...c);
-        paths.add(feat.path);
+        endCmds = usrCmds;
     }
-    return cmds;
+    return endCmds;
 }
 async function resetDbCmd() {
     if (runMode.value == "cli") {
@@ -42,6 +52,7 @@ async function updateFeaturesCmd() {
     for (const el of deleted) {
         console.log("- [feature path]", el);
     }
+    updateUserCmdsCache(cacheFilePath, feats.cmd);
 }
 async function processTasksCmd(args, options) {
     if (options?.conf) {
@@ -92,4 +103,4 @@ async function processTaskCmd(args, options) {
         console.log(colors.dim("Settings") + ":", display);
     }
 }
-export { initUserCmds, resetDbCmd, updateFeaturesCmd, processTaskCmd, processTasksCmd, };
+export { initUserCmds, processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd };

package/dist/cmd/clicmds/{update.js → updateconf.js}

@@ -1,10 +1,11 @@
-import { processConfPath } from "../../conf.js";
+import { cacheFilePath, 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 { runtimeDataError, runtimeInfo } from '../lib/user_msgs.js';
+import { updateUserCmdsCache } from "./cache.js";
 async function updateConfCmd(args) {
     initDb(false, true);
     const { found, path } = readFilePath("conf");
@@ -40,5 +41,6 @@ async function updateConfCmd(args) {
     for (const el of deleted) {
         console.log("- [feature path]", el);
     }
+    updateUserCmdsCache(cacheFilePath, feats.cmd);
 }
 export { updateConfCmd, };

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

@@ -6,8 +6,9 @@ declare class McpClient {
     transport: StdioClientTransport;
     client: Client;
     authorizedTools: Array<string> | null;
+    askUserTools: Array<string> | null;
     tools: Record<string, ToolSpec>;
-    constructor(servername: string, command: string, args: Array<string>, authorizedTools?: Array<string> | null);
+    constructor(servername: string, command: string, args: Array<string>, authorizedTools?: Array<string> | null, askUserTools?: Array<string> | null);
     start(): Promise<void>;
     stop(): Promise<void>;
     extractTools(): Promise<Array<ToolSpec>>;

package/dist/cmd/lib/mcp.js

@@ -1,12 +1,14 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { confirmToolUsage } from "./tools.js";
 class McpClient {
     name;
     transport;
     client;
     authorizedTools = null;
+    askUserTools = null;
     tools = {};
-    constructor(servername, command, args, authorizedTools = null) {
+    constructor(servername, command, args, authorizedTools = null, askUserTools = null) {
         this.name = servername;
         const okargs = new Array();
         for (const arg of args) {
@@ -29,6 +31,9 @@ class McpClient {
         if (authorizedTools) {
             this.authorizedTools = authorizedTools;
         }
+        if (askUserTools) {
+            this.askUserTools = askUserTools;
+        }
     }
     async start() {
         await this.client.connect(this.transport);
@@ -66,6 +71,11 @@ class McpClient {
                 arguments: args,
                 execute: exec
             };
+            if (this.askUserTools) {
+                if (this.askUserTools.includes(tool.name)) {
+                    t.canRun = confirmToolUsage;
+                }
+            }
             this.tools[tool.name] = t;
             toolSpecs.push(t);
         }

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

@@ -1,4 +1,4 @@
 import { TaskOutput } from "@agent-smith/task";
-declare function executeTask(name: string, payload: Record<string, any>, options: Record<string, any>, quiet?: boolean): Promise<TaskOutput>;
+declare function executeTask(name: string, payload: Record<string, any>, options: Record<string, any>): Promise<TaskOutput>;
 declare function executeTaskCmd(name: string, targs?: Array<any>): Promise<TaskOutput>;
 export { executeTask, executeTaskCmd };

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

@@ -13,7 +13,7 @@ import { runtimeDataError, runtimeError, runtimeWarning } from "../user_msgs.js"
 import { formatStats, processOutput } from "../utils.js";
 import { readTask } from "./read.js";
 import { getTaskPrompt } from "./utils.js";
-async function executeTask(name, payload, options, quiet) {
+async function executeTask(name, payload, options) {
     if (!isTaskSettingsInitialized.value) {
         initTaskSettings();
     }
@@ -167,7 +167,7 @@ async function executeTask(name, payload, options, quiet) {
         }
         ++i;
     };
-    const spinnerInit = (name) => ora(`Executing ${name} tool ...`);
+    const spinnerInit = (name) => ora(`Executing ${name} tool ...\n`);
     let tcspinner;
     const onToolCall = (tc) => {
         console.log("⚒️ ", color.bold(name), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
@@ -228,7 +228,7 @@ async function executeTask(name, payload, options, quiet) {
     }
     mcpServers.forEach(async (s) => await s.stop());
     await processOutput(out);
-    if (isChatMode.value) {
+    if (!options?.isToolCall && isChatMode.value) {
         if (tpl) {
             setChatTemplate(tpl);
         }

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

@@ -8,6 +8,7 @@ import { executeWorkflow } from "../workflows/cmd.js";
 import { executeTask } from "./cmd.js";
 import { configureTaskModel, mergeInferParams } from "./conf.js";
 import { openTaskSpec } from "./utils.js";
+import { confirmToolUsage } from "../tools.js";
 async function readTask(name, payload, options, agent) {
     if (options?.debug) {
         console.log("Task", name);
@@ -54,7 +55,19 @@ async function readTask(name, payload, options, agent) {
     }
     if (taskFileSpec?.mcp) {
         for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
-            const mcp = new McpClient(servername, tool.command, tool.arguments, tool?.tools ?? null);
+            const authorizedTools = new Array();
+            const askUserTools = new Array();
+            if (tool?.tools) {
+                tool.tools.forEach(t => {
+                    let tn = t;
+                    if (t.endsWith("?")) {
+                        tn = t.slice(0, -1);
+                        askUserTools.push(tn);
+                    }
+                    authorizedTools.push(tn);
+                });
+            }
+            const mcp = new McpClient(servername, tool.command, tool.arguments, authorizedTools.length > 0 ? authorizedTools : null, askUserTools.length > 0 ? askUserTools : null);
             mcpServers.push(mcp);
             await mcp.start();
             const tools = await mcp.extractTools();
@@ -62,21 +75,29 @@ async function readTask(name, payload, options, agent) {
         }
     }
     if (taskSpec.toolsList) {
-        for (const toolName of taskSpec.toolsList) {
+        for (const rawToolName of taskSpec.toolsList) {
+            let toolName = rawToolName;
+            let autoRunTool = true;
+            if (rawToolName.endsWith("?")) {
+                autoRunTool = false;
+                toolName = rawToolName.slice(0, -1);
+            }
             const { found, tool, type } = readTool(toolName);
             if (!found) {
                 throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
             }
+            const quiet = !options?.debug;
             const lmTool = {
                 ...tool,
                 execute: async (params) => {
                     switch (type) {
                         case "action":
-                            const res = await executeAction(toolName, params, options, true);
+                            const res = await executeAction(toolName, params, options, quiet);
                             return res;
                         case "task":
-                            conf.quiet = !options?.debug;
-                            const tres = await executeTask(name, params, options, true);
+                            options.isToolCall = true;
+                            const tres = await executeTask(toolName, params, options);
+                            options.isToolCall = false;
                             return tres.answer.text;
                         case "workflow":
                             const wres = await executeWorkflow(toolName, params, options);
@@ -86,13 +107,15 @@ async function readTask(name, payload, options, agent) {
                     }
                 }
             };
+            if (!autoRunTool) {
+                lmTool.canRun = confirmToolUsage;
+            }
             taskSpec.tools.push(lmTool);
         }
         delete taskSpec.toolsList;
     }
     ;
     const task = new Task(agent, taskSpec);
-    task.addTools(taskSpec.tools);
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;

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

@@ -1,4 +1,6 @@
 import { FeatureExtension } from '../../interfaces.js';
+import { type ToolCallSpec } from '@locallm/types';
+declare function confirmToolUsage(toolCall: ToolCallSpec): Promise<boolean>;
 declare function extractTaskToolDocAndVariables(name: string, ext: FeatureExtension, dirPath: string): {
     toolDoc: string;
     variables: {
@@ -10,4 +12,4 @@ declare function extractToolDoc(name: string, ext: FeatureExtension, dirPath: st
     found: boolean;
     toolDoc: string;
 };
-export { extractToolDoc, extractTaskToolDocAndVariables, };
+export { extractToolDoc, extractTaskToolDocAndVariables, confirmToolUsage, };

package/dist/cmd/lib/tools.js

@@ -1,6 +1,17 @@
 import YAML from 'yaml';
 import * as fs from 'fs';
 import { readYmlFile } from '../sys/read_yml_file.js';
+import { confirm } from '@inquirer/prompts';
+async function confirmToolUsage(toolCall) {
+    let args;
+    if (toolCall?.arguments) {
+        args = `with arguments ${JSON.stringify(toolCall.arguments)}`;
+    }
+    else {
+        args = "with no arguments";
+    }
+    return await confirm({ message: `Execute tool ${toolCall.name} ${args}?` });
+}
 function _extractToolDoc(filePath, startComment, endComment) {
     try {
         const fileContent = fs.readFileSync(filePath, 'utf-8');
@@ -127,4 +138,4 @@ function extractToolDoc(name, ext, dirPath) {
     }
     return { found: true, toolDoc: spec };
 }
-export { extractToolDoc, extractTaskToolDocAndVariables, };
+export { extractToolDoc, extractTaskToolDocAndVariables, confirmToolUsage, };

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

@@ -46,7 +46,7 @@ async function executeWorkflow(wname, args, options = {}) {
                     if (!pr) {
                         throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
                     }
-                    const tr = await executeTask(step.name, { prompt: pr }, options, true);
+                    const tr = await executeTask(step.name, { prompt: pr }, options);
                     taskRes = { ...tr, ...taskRes };
                 }
                 catch (e) {

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

@@ -1,2 +1,3 @@
 declare function readFile(fp: string): string;
-export { readFile, };
+declare function checkIfFileExists(filePath: string): Promise<boolean>;
+export { readFile, checkIfFileExists, };

package/dist/cmd/sys/read.js

@@ -1,4 +1,6 @@
 import { default as fs } from "fs";
+import { access, constants } from 'fs/promises';
+import { resolve } from 'path';
 function readFile(fp) {
     try {
         return fs.readFileSync(fp, 'utf8');
@@ -7,4 +9,13 @@ function readFile(fp) {
         throw new Error(`reading file ${e}}`);
     }
 }
-export { readFile, };
+async function checkIfFileExists(filePath) {
+    try {
+        await access(resolve(filePath), constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { readFile, checkIfFileExists, };

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

@@ -1,3 +1,3 @@
 import { Command } from "commander";
-declare function readCmds(dir: string): Promise<Array<Command>>;
-export { readCmds };
+declare function readCmd(name: string, cmdPath: string): Promise<Command>;
+export { readCmd };

package/dist/cmd/sys/read_cmds.js

@@ -1,31 +1,12 @@
-import { default as fs } from "fs";
-import { default as path } from "path";
 import { pathToFileURL } from 'url';
-function _readCmdsDir(dir) {
-    const fileNames = new Array;
-    fs.readdirSync(dir).forEach((filename) => {
-        const filepath = path.join(dir, filename);
-        const isDir = fs.statSync(filepath).isDirectory();
-        if (!isDir) {
-            if (filename.endsWith(".ts") || filename.endsWith(".js")) {
-                const name = filename.replace(".js", "").replace(".ts", "");
-                fileNames.push(name);
-            }
-        }
-    });
-    return fileNames;
-}
-async function readCmds(dir) {
+async function readCmd(name, cmdPath) {
     const cmds = new Array();
-    const fileNames = _readCmdsDir(dir);
-    for (const name of fileNames) {
-        const url = pathToFileURL(path.join(dir, name + ".js")).href;
-        const { cmd } = await import(url);
-        if (!cmd) {
-            throw new Error(`command ${name} not found in ${dir}`);
-        }
-        cmds.push(cmd);
+    const url = pathToFileURL(cmdPath).href;
+    const { cmd } = await import(url);
+    if (!cmd) {
+        throw new Error(`command ${name} not found at ${cmdPath}`);
     }
-    return cmds;
+    cmds.push(cmd);
+    return cmd;
 }
-export { readCmds };
+export { readCmd };

package/dist/conf.d.ts

@@ -1,7 +1,8 @@
 declare const confDir: string, dbPath: string;
+declare const cacheFilePath: string;
 declare function processConfPath(confPath: string): Promise<{
     paths: Array<string>;
     pf: string;
     dd: string;
 }>;
-export { confDir, dbPath, processConfPath, };
+export { confDir, dbPath, cacheFilePath, processConfPath, };

package/dist/conf.js

@@ -25,6 +25,7 @@ function getConfigPath(appName, filename) {
     return { confDir: confDir, dbPath: dbPath };
 }
 const { confDir, dbPath } = getConfigPath("agent-smith", "config.db");
+const cacheFilePath = join(import.meta.dirname, "state/auto/usercmds.js");
 async function processConfPath(confPath) {
     createDirectoryIfNotExists(confDir);
     const { found, data } = readConf(confPath);
@@ -114,4 +115,4 @@ async function processConfPath(confPath) {
     }
     return { paths: allPaths, pf: pf, dd: dd };
 }
-export { confDir, dbPath, processConfPath, };
+export { confDir, dbPath, cacheFilePath, processConfPath, };

package/dist/index.js

@@ -3,7 +3,7 @@ import { argv } from 'process';
 import { query } from "./cli.js";
 import { buildCmds, parseCmd } from './cmd/cmds.js';
 import { formatMode, init, inputMode, isChatMode, outputMode, runMode } from './state/state.js';
-import { updateConfCmd } from './cmd/clicmds/update.js';
+import { updateConfCmd } from './cmd/clicmds/updateconf.js';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {

package/dist/state/auto/usercmds.d.ts

@@ -0,0 +1 @@
+export const cmds: any[];

package/dist/state/auto/usercmds.js

@@ -0,0 +1,2 @@
+const cmds = new Array();
+export { cmds };

package/dist/utils/perf.d.ts

@@ -1,7 +1,9 @@
 declare const usePerfTimer: (startTimer?: boolean) => {
-    start: () => number;
+    start: () => void;
     time: () => string;
     timeRaw: () => string | number;
     printTime: () => void;
+    measure: (name: string) => void;
+    final: (name?: string) => void;
 };
 export { usePerfTimer };

package/dist/utils/perf.js

@@ -1,15 +1,38 @@
 const usePerfTimer = (startTimer = true) => {
-    let _startTime;
+    let startTime;
+    const measurements = [];
+    let lastTime;
     if (startTimer) {
-        _startTime = performance.now();
+        startTime = performance.now();
+        lastTime = startTime;
     }
-    const start = () => _startTime = performance.now();
+    const measure = (name) => {
+        const currentTime = performance.now();
+        const elapsedNs = Number(currentTime - lastTime);
+        const elapsedSec = elapsedNs / 1000;
+        measurements.push({ name, time: elapsedSec, percentage: 0 });
+        lastTime = currentTime;
+        console.log(name, elapsedSec);
+    };
+    const final = (name = "") => {
+        const totalTime = Number(performance.now() - startTime) / 1000;
+        console.log("\n*** Performance", name.length > 0 ? `for ${name}` : "", " ***");
+        measurements.forEach(m => {
+            m.percentage = (m.time / totalTime) * 100;
+            console.log(` - ${m.name}: ${m.time.toFixed(6)}s (${m.percentage.toFixed(2)}%)`);
+        });
+        console.log(`Total time: ${totalTime.toFixed(6)}s\n`);
+    };
+    const start = () => {
+        startTime = performance.now();
+        lastTime = startTime;
+    };
     const _end = (raw) => {
-        if (!_startTime) {
+        if (!startTime) {
             throw new Error("the timer has not started, can not end it");
         }
         const endTime = performance.now();
-        const duration = endTime - _startTime;
+        const duration = endTime - startTime;
         if (raw) {
             return duration;
         }
@@ -33,6 +56,8 @@ const usePerfTimer = (startTimer = true) => {
         time,
         timeRaw,
         printTime,
+        measure,
+        final,
     };
 };
 export { usePerfTimer };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@agent-smith/cli",
   "description": "Agent Smith: terminal client for language model agents",
   "repository": "https://github.com/synw/agent-smith",
-  "version": "0.0.99",
+  "version": "0.0.101",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,8 +10,8 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/agent": "^0.1.8",
-    "@agent-smith/task": "^0.1.9",
+    "@agent-smith/agent": "^0.2.0",
+    "@agent-smith/task": "^0.2.0",
     "@agent-smith/tfm": "^0.2.0",
     "@inquirer/prompts": "^8.1.0",
     "@intrinsicai/gbnfgen": "0.12.0",
@@ -31,7 +31,7 @@
     "@agent-smith/tmem-jobs": "^0.0.4",
     "@cfworker/json-schema": "^4.1.1",
     "@commander-js/extra-typings": "^14.0.0",
-    "@locallm/types": "^0.6.5",
+    "@locallm/types": "^0.6.7",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/better-sqlite3": "^7.6.13",