@agent-smith/cli 0.0.109 → 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.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;
         }

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 };

package/dist/state/state.js

@@ -5,21 +5,25 @@ import path from "path";
 import { createDirectoryIfNotExists } from "../cmd/sys/dirs.js";
 import { backend, initBackends } from "./backends.js";
 import { runtimeDataError } from "../utils/user_msgs.js";
+//import { usePerfTimer } from "../main.js";
 let pyShell;
 const inputMode = ref("manual");
 const outputMode = ref("txt");
 const runMode = ref("cmd");
 const formatMode = ref("text");
 const isChatMode = ref(false);
+//const verbosity = ref<VerbosityMode>("quiet");
 const promptfilePath = ref("");
 const dataDirPath = ref("");
 const isStateReady = ref(false);
+const isReady = ref(false);
 const lastCmd = reactive({
     name: "",
     args: [],
 });
 function initFilepaths() {
     const filePaths = readFilePaths();
+    //console.log("FP", filePaths);
     for (const fp of filePaths) {
         switch (fp.name) {
             case "promptfile":
@@ -31,20 +35,30 @@ function initFilepaths() {
     }
 }
 async function init() {
+    //const perf = usePerfTimer();
     await initState();
-    await initBackends();
+    //perf.measure("initState");
+    if (!isReady.value) {
+        await initBackends();
+    }
+    //perf.measure("initBackends");
     if (!backend.value) {
         runtimeDataError("No backend found, can not initialize agent");
         return;
     }
+    isReady.value = true;
+    //perf.final("init")
+    //console.log("Agent", agent);
 }
 async function initState() {
     if (isStateReady.value) {
         return;
     }
+    //sconsole.log("INIT STATE");    
     initDb(false, false);
     initFilepaths();
     isStateReady.value = true;
+    //console.log("State ready, available features:", readFeatures())
 }
 function _getDataDirPath() {
     if (dataDirPath.value.length == 0) {
@@ -58,4 +72,9 @@ function pluginDataDir(pluginName) {
     createDirectoryIfNotExists(pluginDatapath);
     return pluginDatapath;
 }
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, init, pyShell, };
+/*function setVerbosity(mode: VerbosityMode) {
+    verbosity.value = mode
+}*/
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, init, 
+//setVerbosity,
+pyShell, };

package/dist/state/tasks.d.ts

@@ -2,4 +2,5 @@ import { TaskSettings } from "../interfaces.js";
 declare const tasksSettings: Record<string, TaskSettings>;
 declare const isTaskSettingsInitialized: import("@vue/reactivity").Ref<boolean, boolean>;
 declare function initTaskSettings(): void;
-export { tasksSettings, initTaskSettings, isTaskSettingsInitialized, };
+declare function getTaskSettings(force?: boolean): Record<string, TaskSettings>;
+export { tasksSettings, isTaskSettingsInitialized, initTaskSettings, getTaskSettings };

package/dist/state/tasks.js

@@ -16,6 +16,13 @@ function initTaskSettings() {
         }
         tasksSettings[name] = vals;
     });
+    //console.log("TS", tasksSettings);
     isTaskSettingsInitialized.value = true;
 }
-export { tasksSettings, initTaskSettings, isTaskSettingsInitialized, };
+function getTaskSettings(force = false) {
+    if (!isTaskSettingsInitialized.value === true || force) {
+        initTaskSettings();
+    }
+    return tasksSettings;
+}
+export { tasksSettings, isTaskSettingsInitialized, initTaskSettings, getTaskSettings };

package/dist/utils/text.js

@@ -1,8 +1,10 @@
 function extractBetweenTags(text, startTag, endTag) {
     try {
+        // Find start position
         const startIndex = text.indexOf(startTag);
         if (startIndex === -1)
             return text;
+        // Calculate content boundaries
         let contentStart = startIndex + startTag.length;
         let contentEnd;
         if (endTag) {
@@ -11,10 +13,12 @@ function extractBetweenTags(text, startTag, endTag) {
                 return text;
         }
         else {
+            // Find next newline for self-closing tags
             contentEnd = text.indexOf('\n', contentStart);
             if (contentEnd === -1)
                 contentEnd = text.length;
         }
+        // Extract content
         return text.substring(contentStart, contentEnd).trim();
     }
     catch (error) {

package/dist/utils/user_msgs.js

@@ -6,12 +6,14 @@ function runtimeError(...msg) {
 }
 function runtimeWarning(...msg) {
     console.warn("⚠️", colors.dim("Runtime warning:"), ...msg);
+    //exit(1)
 }
 function runtimeDataError(...msg) {
     console.warn("❌", colors.dim("Runtime data error:"), ...msg);
     exit(1);
 }
 function runtimeInfo(...msg) {
+    //console.log("ℹ️ ", colors.dim("Info:"), ...msg);
     console.log("📫", colors.dim("Info:"), ...msg);
 }
 export { runtimeError, runtimeWarning, runtimeDataError, runtimeInfo, };