@agent-smith/cli 0.0.70 → 0.0.80

package/dist/conf.js

@@ -1,8 +1,9 @@
 import path from "path";
 import { readConf } from "./cmd/sys/read_conf.js";
-import { insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
+import { upsertBackends, insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
 import { buildPluginsPaths } from "./state/plugins.js";
 import { runtimeError } from "./cmd/lib/user_msgs.js";
+import { localBackends } from "./const.js";
 const confDir = path.join(process.env.HOME, ".config/agent-smith/cli");
 const dbPath = path.join(confDir, "config.db");
 async function processConfPath(confPath) {
@@ -10,7 +11,54 @@ async function processConfPath(confPath) {
     if (!found) {
         runtimeError(`Config file ${confPath} not found`);
     }
+    console.log(data);
     const allPaths = new Array();
+    const backends = {};
+    let defaultBackendName = "";
+    if (data?.backends) {
+        for (const [name, val] of Object.entries(data.backends)) {
+            switch (name) {
+                case "local":
+                    const bs = val;
+                    bs.forEach(b => {
+                        if (!["llamacpp", "koboldcpp", "ollama"].includes(b)) {
+                            throw new Error(`Unknow backend default value: ${b}`);
+                        }
+                        const lb = localBackends[b];
+                        backends[lb.name] = lb;
+                    });
+                    break;
+                case "default":
+                    const v1 = val;
+                    defaultBackendName = v1;
+                    break;
+                default:
+                    const v3 = val;
+                    let apiKey = undefined;
+                    if (v3?.apiKey) {
+                        apiKey = v3.apiKey;
+                    }
+                    const ib = {
+                        name: name,
+                        type: v3.type,
+                        url: v3.url,
+                        isDefault: false,
+                    };
+                    if (apiKey) {
+                        ib.apiKey = apiKey;
+                    }
+                    backends[name] = ib;
+                    break;
+            }
+        }
+    }
+    console.log("Default backend:", defaultBackendName);
+    console.dir(backends, { depth: 4 });
+    if (!Object.keys(backends).includes(defaultBackendName)) {
+        throw new Error(`Undeclared default backend: ${defaultBackendName}`);
+    }
+    backends[defaultBackendName].isDefault = true;
+    upsertBackends(Object.values(backends));
     if (data?.features) {
         allPaths.push(...data.features);
         const fts = new Array();

package/dist/const.d.ts

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

package/dist/const.js

@@ -0,0 +1,24 @@
+const localBackends = {
+    llamacpp: {
+        name: "llamacpp",
+        type: "llamacpp",
+        url: "http://localhost:8080",
+        apiKey: "",
+        isDefault: false,
+    },
+    koboldcpp: {
+        name: "koboldcpp",
+        type: "koboldcpp",
+        url: "http://localhost:5001",
+        apiKey: "",
+        isDefault: false,
+    },
+    ollama: {
+        name: "ollama",
+        type: "ollama",
+        url: "http://localhost:11434",
+        apiKey: "",
+        isDefault: false,
+    },
+};
+export { localBackends };

package/dist/db/read.d.ts

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

package/dist/db/read.js

@@ -8,6 +8,15 @@ function readFeaturePaths() {
     });
     return f;
 }
+function readBackends() {
+    const stmt = db.prepare("SELECT name, type, url, apiKey, isdefault FROM backend");
+    const data = stmt.all();
+    const bks = {};
+    data.forEach((row) => {
+        bks[row.name] = { name: row.name, type: row.type, url: row.url, apiKey: row.apiKey, isDefault: row.isdefault === 1 };
+    });
+    return bks;
+}
 function readPlugins() {
     const stmt = db.prepare("SELECT name, path FROM plugin");
     const data = stmt.all();
@@ -135,4 +144,4 @@ function readModel(shortname) {
     }
     return { found: false, modelData: {} };
 }
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, readBackends, };

package/dist/db/schemas.js

@@ -71,6 +71,14 @@ const model = `CREATE TABLE IF NOT EXISTS model (
     shortname TEXT UNIQUE NOT NULL,
     data TEXT NOT NULL
 );`;
+const backend = `CREATE TABLE IF NOT EXISTS backend (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    type TEXT NOT NULL CHECK ( type IN ('llamacpp', 'koboldcpp', 'ollama', 'openai') ),
+    url TEXT NOT NULL,
+    isdefault INTEGER NOT NULL,
+    apiKey TEXT
+);`;
 const schemas = [
     filepath,
     featurespath,
@@ -84,5 +92,6 @@ const schemas = [
     model,
     modelfile,
     adaptater,
+    backend,
 ];
 export { schemas };

package/dist/db/write.d.ts

@@ -1,6 +1,8 @@
-import { Features, DbModelDef } from "../interfaces.js";
+import { Features, DbModelDef, InferenceBackend } from "../interfaces.js";
 declare function updatePromptfilePath(pf: string): void;
 declare function updateDataDirPath(dd: string): void;
+declare function setDefaultBackend(name: string): void;
+declare function upsertBackends(bdata: Array<InferenceBackend>): boolean;
 declare function insertFeaturesPathIfNotExists(path: string): boolean;
 declare function insertPluginIfNotExists(n: string, p: string): boolean;
 declare function cleanupFeaturePaths(paths: Array<string>): Array<string>;
@@ -8,4 +10,4 @@ declare function updateAliases(feats: Features): void;
 declare function updateModels(models: Array<DbModelDef>): void;
 declare function updateFeatures(feats: Features): void;
 declare function upsertFilePath(name: string, newPath: string): boolean;
-export { updatePromptfilePath, updateDataDirPath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };

package/dist/db/write.js

@@ -13,6 +13,42 @@ function updateDataDirPath(dd) {
     const stmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
     stmt.run("datadir", dd);
 }
+function setDefaultBackend(name) {
+    const updateStmt = db.prepare("UPDATE backend SET isdefault = 0 WHERE isdefault = 1");
+    updateStmt.run();
+    const nupdStmt = db.prepare("UPDATE backend SET isdefault = 1 WHERE name = ?");
+    nupdStmt.run(name);
+}
+function upsertBackends(bdata) {
+    let hasUpdates = false;
+    const existingStmt = db.prepare("SELECT name FROM backend");
+    const existingBackends = existingStmt.all();
+    const existingNames = new Set(existingBackends.map(b => b.name));
+    const newNames = new Set(bdata.map(b => b.name));
+    const toDelete = Array.from(existingNames).filter(name => !newNames.has(name));
+    if (toDelete.length > 0) {
+        const deleteStmt = db.prepare("DELETE FROM backend WHERE name = ?");
+        for (const name of toDelete) {
+            deleteStmt.run(name);
+        }
+        hasUpdates = true;
+    }
+    for (const backend of bdata) {
+        const stmt1 = db.prepare("SELECT * FROM backend WHERE name = ?");
+        const result = stmt1.get(backend.name);
+        if (result?.id) {
+            const updateStmt = db.prepare("UPDATE backend SET type = ?, url = ?, apiKey = ?, isdefault = ? WHERE name = ?");
+            updateStmt.run(backend.type, backend.url, backend?.apiKey ?? "NULL", backend.isDefault ? 1 : 0, backend.name);
+            hasUpdates = true;
+        }
+        else {
+            const stmt = db.prepare("INSERT INTO backend (name,type,url,apiKey,isdefault) VALUES (?,?,?,?,?)");
+            stmt.run(backend.name, backend.type, backend.url, backend?.apiKey ?? "NULL", backend.isDefault ? 1 : 0);
+            hasUpdates = true;
+        }
+    }
+    return hasUpdates;
+}
 function insertFeaturesPathIfNotExists(path) {
     const stmt1 = db.prepare("SELECT * FROM featurespath WHERE path = ?");
     const result = stmt1.get(path);
@@ -157,7 +193,7 @@ function updateFeatures(feats) {
         if (toolDoc.length > 0) {
             upsertTool(feat.name, "task", toolDoc);
         }
-        if (variables.required.length > 0 || variables.optional.length > 0) {
+        if (Object.keys(variables.required).length > 0 || Object.keys(variables.optional).length > 0) {
             updateVariables(feat.name, JSON.stringify(variables, null, "  "));
         }
     });
@@ -194,4 +230,4 @@ function upsertFilePath(name, newPath) {
         return true;
     }
 }
-export { updatePromptfilePath, updateDataDirPath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { argv } from 'process';
-import { initAgent } from './agent.js';
 import { query } from "./cli.js";
 import { buildCmds, parseCmd } from './cmd/cmds.js';
 import { formatMode, initState, inputMode, isChatMode, outputMode, runMode } from './state/state.js';
 import { updateConfCmd } from './cmd/clicmds/update.js';
+import { initBackends } from './state/backends.js';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {
@@ -17,7 +17,7 @@ async function main() {
         }
     }
     await initState();
-    await initAgent();
+    await initBackends();
     const program = await buildCmds();
     program.hook('preAction', async (thisCommand, actionCommand) => {
         const options = actionCommand.opts();

package/dist/interfaces.d.ts

@@ -1,15 +1,11 @@
-import { BaseLmTask, ModelSpec } from "@agent-smith/lmtask";
-import { InferenceParams } from "@locallm/types";
-interface FeatureVariables {
-    required: Array<string>;
-    optional: Array<string>;
-}
+import { TaskDef, ModelSpec, TaskVariables } from "@agent-smith/task";
+import { InferenceParams, LmProviderType } from "@locallm/types";
 interface FeatureSpec {
     id?: number;
     name: string;
     path: string;
     ext: FeatureExtension;
-    variables?: FeatureVariables;
+    variables?: TaskVariables;
 }
 interface Features {
     task: Array<{
@@ -43,11 +39,24 @@ interface Features {
         ext: ModelFileExtension;
     }>;
 }
+interface ConfInferenceBackend {
+    type: LmProviderType;
+    url: string;
+    apiKey?: string;
+}
+interface InferenceBackend extends ConfInferenceBackend {
+    name: string;
+    isDefault?: boolean;
+}
+interface BackendEntries {
+    [key: string]: ConfInferenceBackend | string | Array<"llamacpp" | "koboldcpp" | "ollama">;
+}
 interface ConfigFile {
     promptfile?: string;
     datadir?: string;
     features?: Array<string>;
     plugins?: Array<string>;
+    backends?: BackendEntries;
 }
 interface Settings {
     name: string;
@@ -75,9 +84,8 @@ interface ModelPack {
     default: string;
     recommended?: Array<string>;
 }
-interface LmTaskFileSpec extends BaseLmTask {
+interface LmTaskFileSpec extends TaskDef {
     ctx: number;
-    model?: ModelSpec;
     modelpack?: ModelPack;
     mcp?: McpServerSpec;
 }
@@ -93,6 +101,10 @@ interface FinalLmTaskConfig {
     model?: ModelSpec;
     modelname?: string;
 }
+interface WorkflowStep {
+    type: string;
+    run: FeatureExecutor;
+}
 interface McpServerSpec {
     command: string;
     arguments: string[];
@@ -125,4 +137,5 @@ type CmdExtension = "js";
 type ModelFileExtension = "yml";
 type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension | ModelFileExtension;
 type AliasType = "task" | "action" | "workflow";
-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, McpServerSpec, McpServerTool, };
+type FeatureExecutor<I = any, O = any> = (params: I, options: Record<string, any>) => Promise<O>;
+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, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, };

package/dist/main.d.ts

@@ -3,14 +3,14 @@ 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 { initAgent } from "./agent.js";
 import { initState, pluginDataDir } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.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";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, LmTaskConf, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, };
+import { readTask } from "./cmd/lib/tasks/read.js";
+import { FeatureType } from "./interfaces.js";
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, readTask, FeatureType, };

package/dist/main.js

@@ -3,7 +3,6 @@ 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 { initAgent } from "./agent.js";
 import { initState, pluginDataDir } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
 import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
@@ -12,4 +11,5 @@ import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
 import { extractBetweenTags, splitThinking } from "./utils/text.js";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, };
+import { readTask } from "./cmd/lib/tasks/read.js";
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, readTask, };

package/dist/state/backends.d.ts

@@ -0,0 +1,7 @@
+import { Lm } from "@locallm/api";
+declare const backend: import("@vue/reactivity").Ref<Lm | undefined, Lm | undefined>;
+declare const backends: Record<string, Lm>;
+declare function initBackends(isVerbose?: boolean): Promise<void>;
+declare function setBackend(name: string, isVerbose?: boolean): Promise<void>;
+declare function listBackends(): Promise<void>;
+export { backend, backends, initBackends, listBackends, setBackend };

package/dist/state/backends.js

@@ -0,0 +1,128 @@
+import { Lm } from "@locallm/api";
+import { reactive, ref } from "@vue/reactivity";
+import colors from "ansi-colors";
+import { readBackends } from "../db/read.js";
+import { setDefaultBackend } from "../db/write.js";
+import { runtimeDataError } from "../utils/user_msgs.js";
+const backend = ref();
+const backends = reactive({});
+const isBackendUp = ref(false);
+async function initBackends(isVerbose = false) {
+    const rmb = readBackends();
+    let defaultBackendName = null;
+    for (const bk of Object.values(rmb)) {
+        const lm = new Lm({
+            providerType: bk.type,
+            serverUrl: bk.url,
+        });
+        lm.name = bk.name;
+        if (bk?.apiKey) {
+            lm.apiKey = bk.apiKey;
+        }
+        ;
+        backends[bk.name] = lm;
+        if (bk.isDefault) {
+            defaultBackendName = bk.name;
+        }
+    }
+    if (defaultBackendName !== null) {
+        backend.value = backends[defaultBackendName];
+        isBackendUp.value = await probeBackend(backend.value, isVerbose);
+        if (isBackendUp.value && backend.value.providerType == "ollama") {
+            await backend.value.modelsInfo();
+        }
+    }
+}
+async function setBackend(name, isVerbose = false) {
+    if (!(Object.keys(backends).includes(name))) {
+        runtimeDataError(`Backend ${name} not found. Available backends: ${Object.keys(backends)}`);
+        return;
+    }
+    backend.value = backends[name];
+    setDefaultBackend(name);
+    console.log("Default backend set to", name);
+    isBackendUp.value = await probeBackend(backend.value, isVerbose);
+}
+async function listBackends() {
+    for (const [name, lm] of Object.entries(backends)) {
+        const bcn = name == backend.value?.name ? colors.bold(name) : name;
+        const buf = new Array("-", bcn, colors.dim("(" + lm.providerType + ") " + lm.serverUrl));
+        console.log(buf.join(" "));
+    }
+}
+const probeBackend = async (lm, isVerbose) => {
+    let isUp = false;
+    switch (lm.providerType) {
+        case "llamacpp":
+            try {
+                const info = await lm.info();
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} up`, info);
+                }
+                isUp = true;
+            }
+            catch (e) {
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} down`, e);
+                }
+            }
+            break;
+        case "koboldcpp":
+            try {
+                const info = await lm.info();
+                if (lm.model.name.length > 0) {
+                    if (isVerbose) {
+                        console.log(`Provider ${lm.name} up`, info);
+                    }
+                    isUp = true;
+                }
+                else {
+                    if (isVerbose) {
+                        console.log(`Provider ${lm.name} down`);
+                    }
+                }
+            }
+            catch (e) {
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} down`, e);
+                }
+            }
+            break;
+        case "ollama":
+            try {
+                await lm.modelsInfo();
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} up`);
+                }
+                isUp = true;
+            }
+            catch (e) {
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} down`, e);
+                }
+            }
+            break;
+        case "openai":
+            try {
+                await lm.modelsInfo();
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} up`);
+                }
+                isUp = true;
+            }
+            catch (e) {
+                if (isVerbose) {
+                    console.log(`Provider ${lm.name} down`, e);
+                }
+            }
+            break;
+        case "browser":
+            await lm.modelsInfo();
+            isUp = true;
+            break;
+        default:
+            throw new Error("Unknown provider type");
+    }
+    return isUp;
+};
+export { backend, backends, initBackends, listBackends, setBackend };

package/dist/state/state.d.ts

@@ -8,6 +8,7 @@ declare const formatMode: import("@vue/reactivity").Ref<FormatMode, FormatMode>;
 declare const isChatMode: 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 isStateReady: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const lastCmd: {
     name: string;
     args: Array<string>;
@@ -15,4 +16,4 @@ declare const lastCmd: {
 declare function initFilepaths(): void;
 declare function initState(): Promise<void>;
 declare function pluginDataDir(pluginName: string): string;
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, pyShell, };

package/dist/state/state.js

@@ -48,4 +48,4 @@ function pluginDataDir(pluginName) {
     createDirectoryIfNotExists(pluginDatapath);
     return pluginDatapath;
 }
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, pyShell, };

package/dist/utils/perf.js

@@ -26,7 +26,7 @@ const usePerfTimer = (startTimer = true) => {
             return `${ms.toFixed(2)} milliseconds`;
         if (seconds < 60)
             return `${seconds.toFixed(1)} seconds`;
-        return `${minutes.toFixed(1)} minutes ${seconds % 60} seconds`;
+        return `${minutes.toFixed()} minutes ${(seconds % 60).toFixed()} seconds`;
     };
     return {
         start,

package/dist/utils/user_msgs.js

@@ -1,17 +1,17 @@
 import { exit } from "process";
-import chalk from 'chalk';
+import colors from "ansi-colors";
 function runtimeError(...msg) {
-    console.warn("💥", chalk.dim("Runtime error:"), ...msg);
+    console.warn("💥", colors.dim("Runtime error:"), ...msg);
     exit(1);
 }
 function runtimeWarning(...msg) {
-    console.warn("⚠️", chalk.dim("Runtime warning:"), ...msg);
+    console.warn("⚠️", colors.dim("Runtime warning:"), ...msg);
 }
 function runtimeDataError(...msg) {
-    console.warn("❌", chalk.dim("Runtime data error:"), ...msg);
+    console.warn("❌", colors.dim("Runtime data error:"), ...msg);
     exit(1);
 }
 function runtimeInfo(...msg) {
-    console.log("📫", chalk.dim("Info:"), ...msg);
+    console.log("📫", colors.dim("Info:"), ...msg);
 }
 export { runtimeError, runtimeWarning, runtimeDataError, runtimeInfo, };

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.70",
+  "version": "0.0.80",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,39 +10,38 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/brain": "^0.0.44",
-    "@agent-smith/jobs": "^0.0.14",
-    "@agent-smith/lmtask": "^0.0.46",
+    "@agent-smith/agent": "^0.0.4",
+    "@agent-smith/task": "^0.0.4",
     "@agent-smith/tfm": "^0.1.2",
-    "@inquirer/prompts": "^7.5.3",
-    "@inquirer/select": "^4.2.3",
-    "@modelcontextprotocol/sdk": "^1.13.0",
-    "@vue/reactivity": "^3.5.17",
+    "@inquirer/prompts": "^7.8.6",
+    "@intrinsicai/gbnfgen": "0.12.0",
+    "@locallm/api": "0.4.2",
+    "@modelcontextprotocol/sdk": "^1.18.2",
+    "@vue/reactivity": "^3.5.22",
     "ansi-colors": "^4.1.3",
-    "better-sqlite3": "^11.10.0",
-    "chalk": "^5.4.1",
-    "clipboardy": "^4.0.0",
-    "commander": "^14.0.0",
+    "better-sqlite3": "^12.4.1",
+    "clipboardy": "^5.0.0",
+    "commander": "^14.0.1",
     "marked-terminal": "^7.3.0",
-    "modprompt": "^0.11.8",
-    "ora": "^8.2.0",
+    "modprompt": "^0.12.0",
+    "ora": "^9.0.0",
     "python-shell": "^5.0.0",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@agent-smith/tmem-jobs": "^0.0.4",
     "@commander-js/extra-typings": "^14.0.0",
-    "@locallm/types": "^0.1.9",
+    "@locallm/types": "^0.4.2",
     "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-typescript": "^12.1.3",
+    "@rollup/plugin-typescript": "^12.1.4",
     "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.6.0",
     "restmix": "^0.5.0",
-    "rollup": "^4.44.0",
+    "rollup": "^4.52.3",
     "ts-node": "^10.9.2",
     "tslib": "2.8.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "type": "module",
   "preferGlobal": true,

package/dist/agent.d.ts

@@ -1,7 +0,0 @@
-import { LmTaskBuilder } from "@agent-smith/lmtask";
-import { marked } from 'marked';
-import { FeatureType } from "./interfaces.js";
-declare let brain: import("@agent-smith/brain").AgentBrain<Record<string, any>>;
-declare const taskBuilder: LmTaskBuilder<FeatureType, Record<string, any>>;
-declare function initAgent(): Promise<boolean>;
-export { brain, initAgent, marked, taskBuilder };