@agent-smith/cli 0.0.109 → 0.0.111

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

@@ -22,6 +22,7 @@ async function executeWorkflow(wname, args, options = {}) {
     let i = 0;
     const finalTaskIndex = stepNames.length - 1;
     let taskRes = { cmdArgs: args };
+    //console.log("WPARAMS", taskRes);
     let prevStepType = null;
     for (const step of workflow) {
         if (isDebug || isVerbose) {
@@ -93,6 +94,8 @@ async function executeWorkflow(wname, args, options = {}) {
                 break;
             case "action":
                 try {
+                    //console.log("EXEC ACTION ARGS", taskRes);
+                    //const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
                     let actArgs;
                     if (i == 0) {
                         actArgs = taskRes.cmdArgs;
@@ -105,12 +108,15 @@ async function executeWorkflow(wname, args, options = {}) {
                         actArgs = taskRes;
                     }
                     const ares = await executeAction(step.name, actArgs, options, true);
+                    //console.log("WF ACTION RES", typeof ares, ares);
+                    //console.log("LAST ACT", i, finalTaskIndex);
                     if (i == finalTaskIndex && !options?.isToolCall && !options?.quiet) {
                         console.log(ares);
                         break;
                     }
                     if (typeof ares == "string" || Array.isArray(ares)) {
                         taskRes.args = ares;
+                        //console.log("ARRAY ACTION RES", taskRes)
                     }
                     else {
                         taskRes = { ...ares, ...taskRes };
@@ -119,12 +125,17 @@ async function executeWorkflow(wname, args, options = {}) {
                 catch (e) {
                     throw new Error(`workflow action ${i + 1}: ${e}`);
                 }
+                //console.log("END ACTION", step.name)
                 break;
             case "adaptater":
                 try {
+                    //console.log("WF AD ARGS IN", taskRes);
+                    //console.log("AD OPTS IN", options);
                     let actArgs;
                     if (i == 0) {
+                        //console.log("TR", taskRes);
                         actArgs = taskRes.cmdArgs;
+                        //console.log("ACT ARGS", actArgs);
                         const inputData = await getInputFromOptions(options);
                         if (inputData) {
                             actArgs.push(inputData);
@@ -134,16 +145,21 @@ async function executeWorkflow(wname, args, options = {}) {
                         actArgs = taskRes;
                     }
                     const adres = await executeAdaptater(step.name, actArgs, options);
+                    //console.log("WF AD FINAL RES", taskRes);
+                    //console.log("LAST ACT", i, finalTaskIndex);
                     if (i == finalTaskIndex && !options?.isToolCall && !options?.quiet) {
                         console.log(adres);
                         break;
                     }
+                    //console.log("WF AD RES", typeof adres, adres);
                     if (typeof adres == "string" || Array.isArray(adres)) {
                         taskRes.args = adres;
+                        //console.log("WF AD IT RES", taskRes);
                     }
                     else {
                         taskRes = { ...adres };
                     }
+                    //console.log("WF ADAPT RES", typeof ares, Array.isArray(ares) ? ares.length : "NA");
                 }
                 catch (e) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
@@ -156,7 +172,13 @@ async function executeWorkflow(wname, args, options = {}) {
                         throw new Error(`Command ${step.name} not found`);
                     }
                     const url = pathToFileURL(path).href;
-                    const jsa = await import(url);
+                    let jsa;
+                    try {
+                        jsa = await import(/* @vite-ignore */ url);
+                    }
+                    catch (e) {
+                        throw new Error(`cmd import error ${e}`);
+                    }
                     if (!jsa?.runCmd) {
                         runtimeError(`workflow ${wname}: can not import the runCmd function from step ${i} for command ${step.name}: please add a runCmd function export`);
                         return;
@@ -188,12 +210,21 @@ async function executeWorkflow(wname, args, options = {}) {
                 throw new Error(`unknown workflow step type ${step.type} in workflow ${wname}`);
         }
         prevStepType = step.type;
+        //console.log("WF NODE RES", step.type, taskRes);
+        /*if (isDebug) {
+            console.log("->", params);
+        }*/
+        //console.log("WFR", taskRes)
         ++i;
     }
+    //console.log("WF RES")
     return taskRes;
 }
 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);
 }
 export { executeWorkflow, executeWorkflowCmd };

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

@@ -3,6 +3,7 @@ import YAML from 'yaml';
 import { getFeatureSpec } from '../../../state/features.js';
 async function _createWorkflowFromSpec(spec) {
     const steps = [];
+    //console.log("Create WF. Steps:", spec);
     for (const step of spec.steps) {
         const type = Object.keys(step)[0];
         const sval = step[type];
@@ -13,9 +14,11 @@ async function _createWorkflowFromSpec(spec) {
         };
         steps.push(wf);
     }
+    //console.log("STEPS", Object.keys(steps).length, steps);
     return steps;
 }
 async function _readWorkflowFromDisk(name) {
+    //const fp = path.join(jobsPath, `${name}.yml`);
     const { found, path } = getFeatureSpec(name, "workflow");
     if (!found) {
         return { found: false, data: {} };
@@ -37,8 +40,10 @@ async function readWorkflow(name) {
     switch (ext) {
         case "yml":
             const { data } = await _readWorkflowFromDisk(name);
+            //console.log("WF DATA", data);
             try {
                 const workflow = await _createWorkflowFromSpec(data);
+                //console.log("WF END", found, workflow);
                 if (!found) {
                     return { found: false, workflow: [] };
                 }

package/dist/cmd/options.js

@@ -4,6 +4,7 @@ const displayOptions = [
     new Option("-d, --debug", "use the debug mode"),
 ];
 const inferenceOptions = [
+    //new Option("-s, --stream", "use the stream mode"),
     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"),

package/dist/cmd/sys/clipboard.js

@@ -1,8 +1,33 @@
 import clipboard from 'clipboardy';
+//import { execute } from "./execute.js";
+//const { platform } = process;
 async function readClipboard() {
+    /*let res = "";
+    if (platform == "linux") {
+        res = await execute("xclip", ["-o", "-selection", "primary"]);
+    } else {
+        res = await clipboard.read();
+    }
+    return res*/
     return await clipboard.read();
 }
 async function writeToClipboard(data) {
     await clipboard.write(data);
 }
+/*import { platform } from "os";
+
+async function getClipboard(): Promise<string> {
+    const currentPlatform = platform();
+    
+    switch (currentPlatform) {
+        case 'darwin': // macOS
+            return await execute("pbpaste", []);
+        case 'win32': // Windows
+            return await execute("powershell", ["-command", "Get-Clipboard"]);
+        case 'linux': // Linux
+            return await execute("xclip", ["-o", "-selection", "clipboard"]);
+        default:
+            throw new Error(`Unsupported platform: ${currentPlatform}`);
+    }
+}*/
 export { readClipboard, writeToClipboard, };

package/dist/cmd/sys/execute.js

@@ -6,6 +6,7 @@ async function execute(command, args = [], { onStdout = (data) => { }, onStderr
         throw err; },
 }) {
     let buffer = new Array();
+    //console.log("Cmd args:", args)
     const useShell = platform() === 'win32';
     const child = spawn(command, args, { shell: useShell });
     child.stdout.setEncoding('utf8');

package/dist/cmd/sys/read_cmds.js

@@ -4,7 +4,7 @@ async function readCmd(name, cmdPath) {
     const url = pathToFileURL(cmdPath).href;
     let _cmd;
     try {
-        const mod = await import(url);
+        const mod = await import(/* @vite-ignore */ url);
         _cmd = mod.cmd;
     }
     catch (e) {
@@ -19,7 +19,7 @@ async function readCmd(name, cmdPath) {
 async function readUserCmd(name, cmdPath) {
     const url = pathToFileURL(cmdPath).href;
     try {
-        const mod = await import(url);
+        const mod = await import(/* @vite-ignore */ url);
         const cmdMod = mod.cmd;
         const uc = {
             name: cmdMod.name,

package/dist/cmd/sys/read_conf.js

@@ -6,6 +6,7 @@ function readConf(confPath) {
     }
     const file = fs.readFileSync(confPath, 'utf8');
     const data = YAML.parse(file);
+    //console.log("READ CONF", data);
     return { data: data, found: true };
 }
 export { readConf };

package/dist/cmd/sys/read_features.js

@@ -4,6 +4,7 @@ function _readDir(dir, ext) {
     const fileNames = new Array;
     fs.readdirSync(dir).forEach((filename) => {
         const filepath = path.join(dir, filename);
+        //console.log("F", filepath);
         const isDir = fs.statSync(filepath).isDirectory();
         if (!isDir) {
             if (ext.includes(path.extname(filename))) {

package/dist/cmd/sys/run_python.js

@@ -17,16 +17,20 @@ async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, onEmitLi
         res.data.push(msg);
     }
     rsShell.on('message', function (message) {
+        //console.log("MSG", message);
         handleLine(message);
     });
     rsShell.on('stderr', function (err) {
         console.log("STDERR", err);
     });
     rsShell.on('pythonError', function (err) {
+        //console.log("PYERR", `${err.message}, ${err.traceback}`);
         res.error = new Error(`${err.traceback} ${err.message}`);
         promiseResolve(true);
     });
     rsShell.end(function (err, code, signal) {
+        //console.log("END", code, signal);
+        //console.log("DATA", res);
         promiseResolve(true);
     });
     await promise;

package/dist/conf.d.ts

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

package/dist/conf.js

@@ -18,7 +18,7 @@ function getConfigPath(appName, filename) {
         confDir = join(homedir(), 'Library', 'Application Support', appName);
         dbPath = join(homedir(), 'Library', 'Application Support', appName, filename);
     }
-    else {
+    else { // Linux, BSD, etc.
         confDir = join(homedir(), '.config', appName);
         dbPath = join(homedir(), '.config', appName, filename);
     }
@@ -31,7 +31,9 @@ async function processConfPath(confPath) {
     if (!found) {
         runtimeError(`Config file ${confPath} not found`);
     }
+    //console.log(data)
     const allPaths = new Array();
+    // backends
     const backends = {};
     let defaultBackendName = "";
     if (data?.backends) {
@@ -72,11 +74,13 @@ async function processConfPath(confPath) {
         }
     }
     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));
+    // features and plugins from conf
     if (data?.features) {
         allPaths.push(...data.features);
         const fts = new Array();
@@ -114,4 +118,4 @@ async function processConfPath(confPath) {
     }
     return { paths: allPaths, pf: pf, dd: dd };
 }
-export { confDir, dbPath, processConfPath, };
+export { confDir, dbPath, processConfPath, getConfigPath, };

package/dist/db/db.js

@@ -5,6 +5,7 @@ import { confDir, dbPath } from "../conf.js";
 let db;
 const debugDb = false;
 function initDb(isVerbose, execSchema) {
+    //console.log("DBP", dbPath);
     if (execSchema) {
         createDirectoryIfNotExists(confDir, true);
         db = new DatabaseConstructor(dbPath, { fileMustExist: false, verbose: debugDb ? console.log : undefined });

package/dist/db/read.js

@@ -27,6 +27,7 @@ function readPlugins() {
     return f;
 }
 function readFeaturesType(type) {
+    //console.log(`SELECT name, path, ext, variables FROM ${type}`)
     const stmt = db.prepare(`SELECT name, path, ext, variables FROM ${type}`);
     const data = stmt.all();
     const res = {};

package/dist/db/write.js

@@ -20,10 +20,13 @@ function setDefaultBackend(name) {
 }
 function upsertBackends(bdata) {
     let hasUpdates = false;
+    // Get all existing backend names
     const existingStmt = db.prepare("SELECT name FROM backend");
     const existingBackends = existingStmt.all();
     const existingNames = new Set(existingBackends.map(b => b.name));
+    // Create a set of new backend names for comparison
     const newNames = new Set(bdata.map(b => b.name));
+    // Delete backends that are not in the new list
     const toDelete = Array.from(existingNames).filter(name => !newNames.has(name));
     if (toDelete.length > 0) {
         const deleteStmt = db.prepare("DELETE FROM backend WHERE name = ?");
@@ -32,6 +35,7 @@ function upsertBackends(bdata) {
         }
         hasUpdates = true;
     }
+    // Upsert the new backends
     for (const backend of bdata) {
         const stmt1 = db.prepare("SELECT * FROM backend WHERE name = ?");
         const result = stmt1.get(backend.name);
@@ -113,13 +117,19 @@ function upsertAndCleanFeatures(feats, type) {
     const stmt = db.prepare(`SELECT name FROM ${type}`);
     const rows = stmt.all();
     const names = rows.map(row => row.name);
+    // cleanup removed features
     const availableFeatsNames = feats.map((f) => f.name);
+    //console.log("NAMES", names);
+    //console.log("AVAILABLE", availableFeatsNames);
     const newFeatures = new Array();
     names.forEach((name) => {
+        //console.log(name, !availableFeatsNames.includes(name));
         if (!availableFeatsNames.includes(name)) {
+            //console.log("DELETE", name);
             const deleteStmt = db.prepare(`DELETE FROM ${type} WHERE name = ?`);
             deleteStmt.run(name);
             console.log("-", "[" + type + "]", name);
+            // check if the feature has a tool and delete if if so
             const stmt1 = db.prepare("SELECT * FROM tool WHERE name = ?");
             const result = stmt1.get(name);
             if (result?.id) {
@@ -131,6 +141,7 @@ function upsertAndCleanFeatures(feats, type) {
     });
     feats.forEach((feat) => {
         if (!names.includes(feat.name)) {
+            //console.log("ADD", type, feat);
             if (feat?.variables) {
                 const insertStmt = db.prepare(`INSERT INTO ${type} (name, path, ext, variables) VALUES (?, ?, ?, ?)`);
                 insertStmt.run(feat.name, feat.path, feat.ext, JSON.stringify(feat.variables, null, 2));
@@ -148,15 +159,18 @@ function upsertAndCleanFeatures(feats, type) {
 function updateVariables(name, variableDoc) {
     const stmt1 = db.prepare("SELECT id FROM task WHERE name = ?");
     const result = stmt1.get(name);
+    //console.log("UV res", result);
     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 updateUserCmd(feat) {
     const stmt1 = db.prepare("SELECT id FROM cmd WHERE name = ?");
     const result = stmt1.get(feat.name);
+    //console.log("UV res", result);
     if (!result?.id) {
         return;
     }
@@ -167,38 +181,50 @@ function upsertTool(name, type, toolDoc) {
     const stmt1 = db.prepare("SELECT * FROM tool WHERE name = ?");
     const result = stmt1.get(name);
     if (result?.id) {
+        // Update the existing tool
         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 {
+        // Insert a new tool
         const stmt = db.prepare("INSERT INTO tool (name, spec, type) VALUES (?,?,?)");
         stmt.run(name, toolDoc, type);
+        //console.log("+", "[tool] added from", type, ":", name);
     }
 }
 function updateFeatures(feats) {
+    //console.log("FEATS", feats);
     upsertAndCleanFeatures(feats.agent, "agent");
     feats.agent.forEach((feat) => {
         const { toolDoc, variables } = extractTaskToolDocAndVariables(feat.name, feat.ext, feat.path);
+        //const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
+        //console.log(`TASK ${feat.name} TOOL DOC`, toolDoc);
         if (toolDoc.length > 0) {
             upsertTool(feat.name, "agent", toolDoc);
         }
         if (Object.keys(variables.required).length > 0 || Object.keys(variables.optional).length > 0) {
+            //console.log("UPDATE VARS", feat.name, ":", variables)
             updateVariables(feat.name, JSON.stringify(variables, null, "  "));
         }
     });
     upsertAndCleanFeatures(feats.task, "task");
     feats.task.forEach((feat) => {
         const { toolDoc, variables } = extractTaskToolDocAndVariables(feat.name, feat.ext, feat.path);
+        //const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
+        //console.log(`TASK ${feat.name} TOOL DOC`, toolDoc);
         if (toolDoc.length > 0) {
             upsertTool(feat.name, "task", toolDoc);
         }
         if (Object.keys(variables.required).length > 0 || Object.keys(variables.optional).length > 0) {
+            //console.log("UPDATE VARS", feat.name, ":", variables)
             updateVariables(feat.name, JSON.stringify(variables, null, "  "));
         }
     });
     upsertAndCleanFeatures(feats.action, "action");
     feats.action.forEach((feat) => {
         const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
+        //console.log(`ACTION ${feat.name} TOOL DOC`, found, toolDoc);
         if (found) {
             upsertTool(feat.name, "action", toolDoc);
         }
@@ -206,6 +232,7 @@ function updateFeatures(feats) {
     upsertAndCleanFeatures(feats.workflow, "workflow");
     feats.workflow.forEach((feat) => {
         const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
+        //console.log(`WORKFLOW ${feat.name} TOOL DOC`, toolDoc);
         if (found) {
             upsertTool(feat.name, "workflow", toolDoc);
         }
@@ -218,12 +245,14 @@ function upsertFilePath(name, newPath) {
     const selectStmt = db.prepare("SELECT * FROM filepath WHERE name = ?");
     const result = selectStmt.get(name);
     if (result?.id) {
+        // If the filepath exists, update it
         const q = `UPDATE filepath SET path = ? WHERE name = ?`;
         const stmt = db.prepare(q);
         const updateResult = stmt.run(newPath, name);
         return updateResult.changes > 0;
     }
     else {
+        // If the filepath does not exist, insert it
         const insertStmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
         insertStmt.run(name, newPath);
         return true;
@@ -276,6 +305,7 @@ function upsertTaskSettings(taskName, settings) {
             qvalues.push(settings.backend);
         }
         const q = `UPDATE tasksettings SET ${qparams.join(", ")} WHERE name = ?`;
+        //console.log("Q", q);
         const stmt = db.prepare(q);
         const updateResult = stmt.run(...qvalues, taskName);
         return updateResult.changes > 0;
@@ -326,6 +356,8 @@ function upsertTaskSettings(taskName, settings) {
         const nq = new Array("?");
         qnames.forEach(n => nq.push("?"));
         const q = `INSERT INTO tasksettings (name, ${qnames.join(", ")}) VALUES (${nq.join(", ")})`;
+        //console.log(q);
+        //console.log("VALs", qvalues);
         const insertStmt = db.prepare(q);
         insertStmt.run(taskName, ...qvalues);
         return true;

package/dist/index.js

@@ -5,7 +5,9 @@ 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';
 async function main() {
+    //const perf = usePerfTimer();
     const nargs = argv.length;
     if (nargs == 2) {
         runMode.value = "cli";
@@ -20,10 +22,16 @@ async function main() {
             return;
         }
     }
+    //perf.measure("base");
     await init();
+    //perf.measure("init");
     const program = await buildCmds();
+    //perf.measure("buildCmds");
+    //perf.final("index start");
     program.hook('preAction', async (thisCommand, actionCommand) => {
         const options = actionCommand.opts();
+        //console.log("POPTS", options)
+        //const v = options?.clipboardOutput !== undefined;
         if (options?.chat === true) {
             isChatMode.value = true;
         }
@@ -46,8 +54,10 @@ async function main() {
             break;
         default:
             await parseCmd(program);
+            //console.log("PARSE CMD END")
             break;
     }
+    //console.log("END");
 }
 (async () => {
     await main();

package/dist/main.d.ts

@@ -12,5 +12,20 @@ import { extractBetweenTags, splitThinking } from "./utils/text.js";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
 import { readTask } from "./cmd/lib/tasks/read.js";
-import { FeatureType } from "./interfaces.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, init, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, isStateReady, McpClient, readTask, FeatureType, };
+import { FeatureType, TaskSettings } from "./interfaces.js";
+import { getConfigPath } from "./conf.js";
+import { readFeaturesType, readFilePaths } from "./db/read.js";
+import { readConf } from "./cmd/sys/read_conf.js";
+import { backend } from "./state/backends.js";
+import { getTaskSettings } from "./state/tasks.js";
+import { upsertTaskSettings } from "./db/write.js";
+declare const db: {
+    readFilePaths: typeof readFilePaths;
+    readFeaturesType: typeof readFeaturesType;
+    getTaskSettings: typeof getTaskSettings;
+    upsertTaskSettings: typeof upsertTaskSettings;
+};
+declare const fs: {
+    openTaskSpec: typeof openTaskSpec;
+};
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, init, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, isStateReady, backend, McpClient, readTask, FeatureType, getConfigPath, readConf, TaskSettings, db, fs, };

package/dist/main.js

@@ -12,4 +12,19 @@ import { extractBetweenTags, splitThinking } from "./utils/text.js";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
 import { readTask } from "./cmd/lib/tasks/read.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, init, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, isStateReady, McpClient, readTask, };
+import { getConfigPath } from "./conf.js";
+import { readFeaturesType, readFilePaths } from "./db/read.js";
+import { readConf } from "./cmd/sys/read_conf.js";
+import { backend } from "./state/backends.js";
+import { getTaskSettings } from "./state/tasks.js";
+import { upsertTaskSettings } from "./db/write.js";
+const db = {
+    readFilePaths,
+    readFeaturesType,
+    getTaskSettings,
+    upsertTaskSettings,
+};
+const fs = {
+    openTaskSpec,
+};
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, init, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, isStateReady, backend, McpClient, readTask, getConfigPath, readConf, db, fs, };

package/dist/state/backends.js

@@ -9,8 +9,10 @@ const backends = {};
 const isBackendUp = ref(false);
 async function initBackends() {
     const rmb = readBackends();
+    //console.log("Backends:", rmb)
     let defaultBackendName = null;
     for (const bk of Object.values(rmb)) {
+        //console.log("BK", bk.name);
         let name = bk.name;
         let apiKey = "";
         if (bk?.apiKey) {
@@ -39,6 +41,12 @@ async function initBackends() {
     }
     if (defaultBackendName !== null) {
         backend.value = backends[defaultBackendName];
+        //console.log("Setting default backend", defaultBackendName, "/", backend.value.name)
+        /*isBackendUp.value = await probeBackend(backend.value, isVerbose);
+
+        if (isBackendUp.value && backend.value.providerType == "ollama") {
+            await backend.value.modelsInfo();
+        }*/
     }
 }
 async function setBackend(name, isVerbose = false) {
@@ -52,9 +60,11 @@ async function setBackend(name, isVerbose = false) {
     isBackendUp.value = await probeBackend(backend.value, isVerbose);
 }
 async function listBackends(printResult = true) {
+    //console.log("DEFB", backend.value?.name);
     const allBk = new Array();
     for (const [name, lm] of Object.entries(backends)) {
         const bcn = name == backend.value?.name ? colors.bold(name) : name;
+        //const isUp = await probeBackend(lm, false);
         const buf = new Array("-", bcn, colors.dim("(" + lm.providerType + ") " + lm.serverUrl));
         const str = buf.join(" ");
         if (printResult) {
@@ -103,6 +113,8 @@ const probeBackend = async (lm, isVerbose) => {
             }
             break;
         case "ollama":
+            //console.warn("The Ollama provider is not yet supported");
+            //break;
             try {
                 await lm.modelsInfo();
                 if (isVerbose) {
@@ -117,6 +129,8 @@ const probeBackend = async (lm, isVerbose) => {
             }
             break;
         case "openai":
+            //console.warn("The Ollama provider is not yet supported");
+            //break;
             try {
                 await lm.modelsInfo();
                 if (isVerbose) {

package/dist/state/plugins.js

@@ -5,12 +5,14 @@ async function buildPluginsPaths(names) {
     const plugins = new Array();
     const root = await execute("npm", ["root", "-g"]);
     const rootPath = root.trim();
+    //console.log("PLUGINS", packs);
     names.forEach((p) => {
         plugins.push({
             name: p,
             path: path.join(rootPath, p, "dist")
         });
     });
+    //console.log("PLUGINS PATHS", paths);
     return plugins;
 }
 async function readPluginsPaths() {
@@ -19,6 +21,7 @@ async function readPluginsPaths() {
     plugins.forEach((p) => {
         paths.push(p.path);
     });
+    //console.log("PLUGINS PATHS", paths);
     return paths;
 }
 export { buildPluginsPaths, readPluginsPaths };