@agent-smith/cli 0.0.108 → 0.0.110

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.d.ts

@@ -1,3 +1,7 @@
-import { Command } from "commander";
-declare function readCmd(name: string, cmdPath: string): Promise<Command | null>;
-export { readCmd };
+import type { UserCmdDef } from "../../interfaces.js";
+declare function readCmd(name: string, cmdPath: string): Promise<UserCmdDef | null>;
+declare function readUserCmd(name: string, cmdPath: string): Promise<{
+    found: boolean;
+    userCmd: UserCmdDef;
+}>;
+export { readCmd, readUserCmd, };

package/dist/cmd/sys/read_cmds.js

@@ -2,9 +2,9 @@ import { pathToFileURL } from 'url';
 import { runtimeWarning } from "../lib/user_msgs.js";
 async function readCmd(name, cmdPath) {
     const url = pathToFileURL(cmdPath).href;
-    let _cmd = null;
+    let _cmd;
     try {
-        const mod = await import(url);
+        const mod = await import(/* @vite-ignore */ url);
         _cmd = mod.cmd;
     }
     catch (e) {
@@ -16,4 +16,22 @@ async function readCmd(name, cmdPath) {
     }
     return _cmd;
 }
-export { readCmd };
+async function readUserCmd(name, cmdPath) {
+    const url = pathToFileURL(cmdPath).href;
+    try {
+        const mod = await import(/* @vite-ignore */ url);
+        const cmdMod = mod.cmd;
+        const uc = {
+            name: cmdMod.name,
+            description: cmdMod.description,
+            run: cmdMod.run,
+            options: cmdMod?.options ? cmdMod.options : undefined,
+        };
+        return { found: true, userCmd: uc };
+    }
+    catch (e) {
+        runtimeWarning(`command ${name} not found at ${cmdPath}, ${e}`);
+        return { found: false, userCmd: { name: "", description: "", run: async (a, b) => null } };
+    }
+}
+export { readCmd, readUserCmd, };

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,8 +1,11 @@
+declare function getConfigPath(appName: string, filename: string): {
+    confDir: string;
+    dbPath: string;
+};
 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, cacheFilePath, processConfPath, };
+export { confDir, dbPath, processConfPath, getConfigPath, };

package/dist/conf.js

@@ -18,21 +18,22 @@ 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);
     }
     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);
     if (!found) {
         runtimeError(`Config file ${confPath} not found`);
     }
+    //console.log(data)
     const allPaths = new Array();
+    // backends
     const backends = {};
     let defaultBackendName = "";
     if (data?.backends) {
@@ -73,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();
@@ -115,4 +118,4 @@ async function processConfPath(confPath) {
     }
     return { paths: allPaths, pf: pf, dd: dd };
 }
-export { confDir, dbPath, cacheFilePath, 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,8 +141,15 @@ function upsertAndCleanFeatures(feats, type) {
     });
     feats.forEach((feat) => {
         if (!names.includes(feat.name)) {
-            const insertStmt = db.prepare(`INSERT INTO ${type} (name, path, ext) VALUES (?, ?, ?)`);
-            insertStmt.run(feat.name, feat.path, feat.ext);
+            //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));
+            }
+            else {
+                const insertStmt2 = db.prepare(`INSERT INTO ${type} (name, path, ext) VALUES (?, ?, ?)`);
+                insertStmt2.run(feat.name, feat.path, feat.ext);
+            }
             console.log("+", "[" + type + "]", feat.name, feat.path);
             newFeatures.push(feat);
         }
@@ -142,48 +159,72 @@ 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;
+    }
+    const updateStmt = db.prepare("UPDATE cmd SET variables = ? WHERE id = ?");
+    updateStmt.run(JSON.stringify(feat.variables, null, 2), result.id);
 }
 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);
         }
@@ -191,23 +232,27 @@ 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);
         }
     });
     upsertAndCleanFeatures(feats.adaptater, "adaptater");
     upsertAndCleanFeatures(feats.cmd, "cmd");
+    feats.cmd.forEach(c => updateUserCmd(c));
 }
 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;
@@ -260,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;
@@ -310,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;
         }

package/dist/interfaces.d.ts

@@ -5,7 +5,7 @@ interface FeatureSpec {
     name: string;
     path: string;
     ext: FeatureExtension;
-    variables?: TaskVariables;
+    variables?: TaskVariables | Record<string, any>;
 }
 interface Features {
     agent: Array<{
@@ -22,6 +22,11 @@ interface Features {
         name: string;
         path: string;
         ext: CmdExtension;
+        variables?: {
+            name: string;
+            options?: Array<Array<string> | string>;
+            description: string;
+        };
     }>;
     action: Array<{
         name: string;
@@ -39,6 +44,12 @@ interface Features {
         ext: AdaptaterExtension;
     }>;
 }
+interface UserCmdDef {
+    name: string;
+    description: string;
+    run: (args: any, options: Record<string, any>) => Promise<any>;
+    options?: Array<Array<string> | string>;
+}
 interface ConfInferenceBackend {
     type: LmProviderType;
     url: string;
@@ -151,4 +162,4 @@ type CmdExtension = "js";
 type FeatureExtension = TaskExtension | AgentExtension | CmdExtension | ActionExtension | WorkflowExtension;
 type AliasType = "task" | "agent" | "action" | "workflow";
 type FeatureExecutor<I = any, O = any> = (params: I, options: Record<string, any>) => Promise<O>;
-export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, AgentExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, TaskSettings, };
+export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, AgentExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, TaskSettings, UserCmdDef, };

package/dist/main.d.ts

@@ -3,7 +3,7 @@ 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 { initState, pluginDataDir, init } from "./state/state.js";
+import { initState, pluginDataDir, init, isStateReady } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
 import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
 import { extractToolDoc } from "./cmd/lib/tools.js";
@@ -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, 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

@@ -3,7 +3,7 @@ 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 { initState, pluginDataDir, init } from "./state/state.js";
+import { initState, pluginDataDir, init, isStateReady } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
 import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
 import { extractToolDoc } from "./cmd/lib/tools.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, 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 };