@agent-smith/cli 0.0.39 → 0.0.40

package/dist/cmd/lib/utils.js

@@ -1,10 +1,8 @@
-import { useAgentTask } from "@agent-smith/jobs";
 import { useTemplateForModel } from "@agent-smith/tfm";
-import { default as fs } from "fs";
-import { default as path } from "path";
-import { inputMode, outputMode, promptfile } from "../../state/state.js";
+import { inputMode, outputMode, promptfilePath } from "../../state/state.js";
 import { modes } from "../clicmds/modes.js";
 import { readClipboard, writeToClipboard } from "../sys/clipboard.js";
+import { readFile } from "../sys/read.js";
 const tfm = useTemplateForModel();
 async function setOptions(args = [], options) {
     for (const k of Object.keys(options)) {
@@ -28,12 +26,7 @@ async function setOptions(args = [], options) {
     return args;
 }
 function readPromptFile() {
-    try {
-        return fs.readFileSync(promptfile.value, 'utf8');
-    }
-    catch (e) {
-        return "";
-    }
+    return readFile(promptfilePath.value);
 }
 async function processOutput(res) {
     if (!(outputMode.value == "clipboard")) {
@@ -41,17 +34,8 @@ async function processOutput(res) {
     }
     let data = "";
     if (typeof res == "object") {
-        let hasOutput = false;
-        if (res?.data) {
-            data = res.data;
-            hasOutput = true;
-        }
-        if (res?.text) {
-            data = res.text;
-            hasOutput = true;
-        }
-        if (!hasOutput) {
-            throw new Error(`No data in res: ${JSON.stringify(res, null, "  ")}`);
+        if (res?.answer && res?.stats) {
+            data = res.answer.text;
         }
     }
     else {
@@ -64,26 +48,6 @@ async function processOutput(res) {
         await writeToClipboard(data);
     }
 }
-function readTask(taskpath) {
-    if (!fs.existsSync(taskpath)) {
-        return { ymlTask: "", found: false };
-    }
-    const data = fs.readFileSync(taskpath, 'utf8');
-    return { ymlTask: data, found: true };
-}
-function readTasksDir(dir) {
-    const tasks = new Array();
-    fs.readdirSync(dir).forEach((filename) => {
-        const filepath = path.join(dir, filename);
-        const isDir = fs.statSync(filepath).isDirectory();
-        if (!isDir) {
-            if (filename.endsWith(".yml")) {
-                tasks.push(filename);
-            }
-        }
-    });
-    return tasks;
-}
 function initTaskConf(conf, taskSpec) {
     const _conf = conf;
     let m = taskSpec.model.name;
@@ -189,7 +153,18 @@ function initTaskVars(args, inferParams) {
     const vars = {};
     args.forEach((a) => {
         if (a.includes("=")) {
-            const t = a.split("=");
+            const delimiter = "=";
+            const firstDelimiterIndex = a.indexOf(delimiter);
+            let t = new Array();
+            if (firstDelimiterIndex !== -1) {
+                t = [
+                    a.slice(0, firstDelimiterIndex),
+                    a.slice(firstDelimiterIndex + 1)
+                ];
+            }
+            else {
+                t = [a];
+            }
             const k = t[0];
             const v = t[1];
             switch (k) {
@@ -230,21 +205,4 @@ async function parseInputOptions(options) {
     }
     return out;
 }
-function createJsAction(action) {
-    const task = useAgentTask({
-        id: "",
-        title: "",
-        run: async (args) => {
-            try {
-                const res = await action(args);
-                return { ok: true, data: res };
-            }
-            catch (e) {
-                const err = new Error(`Error executing action ${e}`);
-                return { ok: false, data: {}, error: err };
-            }
-        }
-    });
-    return task;
-}
-export { createJsAction, initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, readTask, readTasksDir, setOptions };
+export { initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, setOptions };

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

@@ -1,3 +1,2 @@
-import { NodeReturnType } from "../../../interfaces.js";
-declare function executeWorkflowCmd(name: string, args?: Array<any>, options?: any): Promise<NodeReturnType<any>>;
+declare function executeWorkflowCmd(name: string, args?: Array<any>, options?: any): Promise<any>;
 export { executeWorkflowCmd, };

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

@@ -1,7 +1,8 @@
 import { isDebug, isVerbose } from "../../../state/state.js";
 import { readWorkflow } from "./read.js";
-import { executeTaskCmd } from "../execute_task.js";
-import { executeActionCmd } from "../execute_action.js";
+import { executeTaskCmd } from "../tasks/cmd.js";
+import { executeActionCmd } from "../actions/cmd.js";
+import { executeAdaptaterCmd } from "../adaptaters/cmd.js";
 async function executeWorkflowCmd(name, args = [], options = {}) {
     const { workflow, found } = await readWorkflow(name);
     if (!found) {
@@ -14,7 +15,7 @@ async function executeWorkflowCmd(name, args = [], options = {}) {
     let params = {};
     let i = 0;
     const finalTaskIndex = stepNames.length + 1;
-    let taskRes = { data: {}, error: new Error("Empty task res") };
+    let taskRes = {};
     for (const [name, step] of Object.entries(workflow)) {
         if (isDebug.value || isVerbose.value) {
             console.log(`${i + 1}: ${step.type} ${name}`);
@@ -23,26 +24,36 @@ async function executeWorkflowCmd(name, args = [], options = {}) {
         switch (step.type) {
             case "task":
                 try {
-                    taskRes = await executeTaskCmd(p, options);
+                    const tr = await executeTaskCmd(p, options);
+                    taskRes = tr;
                 }
                 catch (e) {
-                    throw new Error(`Wokflow task ${i + 1} error: ${e}`);
+                    throw new Error(`workflow task ${i + 1}: ${e}`);
                 }
                 break;
             case "action":
                 try {
                     const ares = await executeActionCmd(p, options, true);
-                    taskRes = ares.data;
+                    taskRes = ares;
                     if (i == finalTaskIndex) {
-                        console.log(taskRes.data);
+                        console.log(taskRes);
                     }
                 }
                 catch (e) {
-                    throw new Error(`Workflow action ${i + 1} error: ${e}`);
+                    throw new Error(`workflow action ${i + 1}: ${e}`);
+                }
+                break;
+            case "adaptater":
+                try {
+                    const ares = await executeAdaptaterCmd(p, options);
+                    taskRes = ares;
+                }
+                catch (e) {
+                    throw new Error(`workflow adaptater ${i + 1}: ${e}`);
                 }
                 break;
             default:
-                throw new Error(`Unknown task type ${step.type} in workflow ${name}`);
+                throw new Error(`unknown task type ${step.type} in workflow ${name}`);
         }
         params = taskRes;
         ++i;

package/dist/cmd/lib/workflows/read.d.ts

@@ -1,7 +1,7 @@
 import { AgentTask } from "@agent-smith/jobs";
-import { FeatureType, NodeReturnType } from '../../../interfaces.js';
+import { FeatureType } from '../../../interfaces.js';
 declare function readWorkflow(name: string): Promise<{
     found: boolean;
-    workflow: Record<string, AgentTask<FeatureType, any, NodeReturnType<any>, Record<string, any>>>;
+    workflow: Record<string, AgentTask<FeatureType, any, any, Record<string, any>>>;
 }>;
 export { readWorkflow, };

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

@@ -2,8 +2,9 @@ import YAML from 'yaml';
 import { default as fs } from "fs";
 import { taskBuilder } from '../../../agent.js';
 import { getFeatureSpec } from '../../../state/features.js';
-import { createJsAction, readTask } from '../utils.js';
-import { pythonAction, systemAction } from './../execute_action.js';
+import { readTask } from "../../sys/read_task.js";
+import { pythonAction, systemAction } from '../actions/cmd.js';
+import { createJsAction } from '../actions/read.js';
 async function _createWorkflowFromSpec(spec) {
     const steps = {};
     for (const step of spec.steps) {
@@ -48,6 +49,16 @@ async function _createWorkflowFromSpec(spec) {
                     throw new Error(`Unknown feature extension ${ext}`);
             }
         }
+        else if (type == "adaptater") {
+            const { found, path } = getFeatureSpec(name, "adaptater");
+            if (!found) {
+                throw new Error(`Adaptater ${name} not found`);
+            }
+            const jsa = await import(path);
+            const act = createJsAction(jsa.action);
+            act.type = "adaptater";
+            steps[name] = act;
+        }
         else {
             const { found, path } = getFeatureSpec(name, "task");
             if (!found) {
@@ -93,11 +104,11 @@ async function readWorkflow(name) {
                 wf = workflow;
             }
             catch (e) {
-                throw new Error(`Workflow create error: ${e}`);
+                throw new Error(`Workflow ${name} create error: ${e}`);
             }
             break;
         default:
-            throw new Error(`Workflow extension ${ext} not implemented`);
+            throw new Error(`Workflow ${name} extension ${ext} not implemented`);
     }
     return { found: true, workflow: wf };
 }

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

@@ -0,0 +1,2 @@
+declare function readFile(fp: string): string;
+export { readFile, };

package/dist/cmd/sys/read.js

@@ -0,0 +1,10 @@
+import { default as fs } from "fs";
+function readFile(fp) {
+    try {
+        return fs.readFileSync(fp, 'utf8');
+    }
+    catch (e) {
+        throw new Error(`reading file ${e}}`);
+    }
+}
+export { readFile, };

package/dist/cmd/sys/read_features.js

@@ -18,10 +18,10 @@ function _readDir(dir, ext) {
 function readFeaturesDir(dir) {
     const feats = {
         task: [],
-        job: [],
         action: [],
         cmd: [],
-        workflow: []
+        workflow: [],
+        adaptater: [],
     };
     let dirpath = path.join(dir, "tasks");
     if (fs.existsSync(dirpath)) {
@@ -37,42 +37,42 @@ function readFeaturesDir(dir) {
             });
         });
     }
-    dirpath = path.join(dir, "jobs");
+    dirpath = path.join(dir, "workflows");
     if (fs.existsSync(dirpath)) {
         const data = _readDir(dirpath, [".yml"]);
         data.forEach((filename) => {
             const parts = filename.split(".");
             const ext = parts.pop();
             const name = parts.join("");
-            feats.job.push({
+            feats.workflow.push({
                 name: name,
                 path: path.join(dirpath),
                 ext: ext,
             });
         });
     }
-    dirpath = path.join(dir, "workflows");
+    dirpath = path.join(dir, "actions");
     if (fs.existsSync(dirpath)) {
-        const data = _readDir(dirpath, [".yml"]);
+        const data = _readDir(dirpath, ["yml", ".js", "mjs", ".py"]);
         data.forEach((filename) => {
             const parts = filename.split(".");
             const ext = parts.pop();
             const name = parts.join("");
-            feats.workflow.push({
+            feats.action.push({
                 name: name,
                 path: path.join(dirpath),
                 ext: ext,
             });
         });
     }
-    dirpath = path.join(dir, "actions");
+    dirpath = path.join(dir, "adaptaters");
     if (fs.existsSync(dirpath)) {
-        const data = _readDir(dirpath, ["yml", ".js", "mjs", ".py"]);
+        const data = _readDir(dirpath, [".js"]);
         data.forEach((filename) => {
             const parts = filename.split(".");
             const ext = parts.pop();
             const name = parts.join("");
-            feats.action.push({
+            feats.adaptater.push({
                 name: name,
                 path: path.join(dirpath),
                 ext: ext,

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

@@ -0,0 +1,6 @@
+declare function readTask(taskpath: string): {
+    found: boolean;
+    ymlTask: string;
+};
+declare function readTasksDir(dir: string): Array<string>;
+export { readTask, readTasksDir, };

package/dist/cmd/sys/read_task.js

@@ -0,0 +1,23 @@
+import { default as fs } from "fs";
+import { default as path } from "path";
+function readTask(taskpath) {
+    if (!fs.existsSync(taskpath)) {
+        return { ymlTask: "", found: false };
+    }
+    const data = fs.readFileSync(taskpath, 'utf8');
+    return { ymlTask: data, found: true };
+}
+function readTasksDir(dir) {
+    const tasks = new Array();
+    fs.readdirSync(dir).forEach((filename) => {
+        const filepath = path.join(dir, filename);
+        const isDir = fs.statSync(filepath).isDirectory();
+        if (!isDir) {
+            if (filename.endsWith(".yml")) {
+                tasks.push(filename);
+            }
+        }
+    });
+    return tasks;
+}
+export { readTask, readTasksDir, };

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

@@ -0,0 +1,2 @@
+declare function deleteFileIfExists(filePath: string): void;
+export { deleteFileIfExists };

package/dist/cmd/sys/reset.js

@@ -0,0 +1,10 @@
+import * as fs from 'fs';
+function deleteFileIfExists(filePath) {
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+    else {
+        throw new Error(`File ${filePath} does not exist.`);
+    }
+}
+export { deleteFileIfExists };

package/dist/cmd/sys/run_python.js

@@ -19,9 +19,12 @@ async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, onEmitLi
     rsShell.on('message', function (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.toString());
+        res.error = new Error(`${err.traceback} ${err.message}`);
+        promiseResolve(true);
     });
     rsShell.end(function (err, code, signal) {
         promiseResolve(true);

package/dist/db/db.d.ts

@@ -1,4 +1,5 @@
 import { Database } from "better-sqlite3";
+declare const dbPath: string;
 declare let db: Database;
 declare function initDb(isVerbose?: boolean): void;
-export { db, initDb, };
+export { db, dbPath, initDb, };

package/dist/db/db.js

@@ -13,4 +13,4 @@ function initDb(isVerbose = false) {
         }
     });
 }
-export { db, initDb, };
+export { db, dbPath, initDb, };

package/dist/db/read.d.ts

@@ -1,4 +1,5 @@
-import { AliasType, FeatureSpec, FeatureType } from "../interfaces.js";
+import { ToolSpec } from "modprompt";
+import { AliasType, FeatureSpec, FeatureType, ToolType } from "../interfaces.js";
 declare function readFeaturePaths(): Array<string>;
 declare function readPlugins(): Array<Record<string, string>>;
 declare function readFeatures(): Record<FeatureType, Record<string, string>>;
@@ -10,5 +11,10 @@ declare function readFeature(name: string, type: FeatureType): {
     found: boolean;
     feature: FeatureSpec;
 };
-declare function readPromptFile(): string;
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readPromptFile };
+declare function readTool(name: string): {
+    found: boolean;
+    tool: ToolSpec;
+    type: ToolType;
+};
+declare function readPromptFilePath(): string;
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readPromptFilePath, readTool, };

package/dist/db/read.js

@@ -27,12 +27,12 @@ function _readFeaturesType(type) {
     return f;
 }
 function readFeatures() {
-    const feats = { task: {}, job: {}, action: {}, cmd: {}, workflow: {} };
+    const feats = { task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {} };
     feats.task = _readFeaturesType("task");
-    feats.job = _readFeaturesType("job");
     feats.action = _readFeaturesType("action");
     feats.cmd = _readFeaturesType("cmd");
     feats.workflow = _readFeaturesType("workflow");
+    feats.adaptater = _readFeaturesType("adaptater");
     return feats;
 }
 function readAliases() {
@@ -60,7 +60,22 @@ function readFeature(name, type) {
     }
     return { found: false, feature: {} };
 }
-function readPromptFile() {
+function readTool(name) {
+    const q = `SELECT id, name, type, spec FROM tool WHERE name='${name}'`;
+    const stmt = db.prepare(q);
+    const result = stmt.get();
+    const tool = JSON.parse(result.spec);
+    tool["name"] = name;
+    if (result?.id) {
+        return {
+            found: true,
+            tool: tool,
+            type: result.type,
+        };
+    }
+    return { found: false, tool: {}, type: "action" };
+}
+function readPromptFilePath() {
     const stmt1 = db.prepare("SELECT * FROM filepath WHERE name = ?");
     const result = stmt1.get("promptfile");
     let res = "";
@@ -69,4 +84,4 @@ function readPromptFile() {
     }
     return res;
 }
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readPromptFile };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readPromptFilePath, readTool, };

package/dist/db/schemas.js

@@ -1,13 +1,13 @@
-const filepaths = `CREATE TABLE IF NOT EXISTS filepath (
+const filepath = `CREATE TABLE IF NOT EXISTS filepath (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL
 );`;
-const featurespaths = `CREATE TABLE IF NOT EXISTS featurespath (
+const featurespath = `CREATE TABLE IF NOT EXISTS featurespath (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     path TEXT NOT NULL
 );`;
-const plugins = `CREATE TABLE IF NOT EXISTS plugin (
+const plugin = `CREATE TABLE IF NOT EXISTS plugin (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL
@@ -18,36 +18,58 @@ const tasks = `CREATE TABLE IF NOT EXISTS task (
     path TEXT NOT NULL,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
-const jobs = `CREATE TABLE IF NOT EXISTS job (
+const workflow = `CREATE TABLE IF NOT EXISTS workflow (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
-const workflow = `CREATE TABLE IF NOT EXISTS workflow (
+const action = `CREATE TABLE IF NOT EXISTS action (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
-    ext TEXT NOT NULL CHECK ( ext IN ('yml') )
+    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
 );`;
-const actions = `CREATE TABLE IF NOT EXISTS action (
+const adaptater = `CREATE TABLE IF NOT EXISTS adaptater (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
-    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py', 'mjs') )
+    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
 );`;
-const cmds = `CREATE TABLE IF NOT EXISTS cmd (
+const tool = `CREATE TABLE IF NOT EXISTS tool (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    spec TEXT NOT NULL,
+    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
+);`;
+const cmd = `CREATE TABLE IF NOT EXISTS cmd (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
     ext TEXT NOT NULL CHECK ( ext IN ('js') )
 );`;
-const aliases = `CREATE TABLE IF NOT EXISTS aliases (
+const alias = `CREATE TABLE IF NOT EXISTS aliases (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
+);`;
+const model = `CREATE TABLE IF NOT EXISTS model (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
-    type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'job', 'workflow') )
+    ctx INTEGER NOT NULL,
+    template TEXT NOT NULL
 );`;
 const schemas = [
-    filepaths, featurespaths, tasks, jobs, workflow, actions, cmds, plugins, aliases
+    filepath,
+    featurespath,
+    tasks,
+    workflow,
+    action,
+    tool,
+    cmd,
+    plugin,
+    alias,
+    model,
+    adaptater,
 ];
 export { schemas };

package/dist/db/write.js

@@ -1,6 +1,7 @@
+import { extractToolDoc } from "../cmd/lib/tools.js";
 import { db } from "./db.js";
 function updatePromptfilePath(pf) {
-    const deleteStmt = db.prepare("DELETE FROM featurespath WHERE path = ?");
+    const deleteStmt = db.prepare("DELETE FROM filepath WHERE name = ?");
     deleteStmt.run("promptfile");
     const stmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
     stmt.run("promptfile", pf);
@@ -59,9 +60,6 @@ function updateAliases(feats) {
     feats.action.forEach((feat) => {
         existingAliases = _updateAlias(existingAliases, feat.name, "action");
     });
-    feats.job.forEach((feat) => {
-        existingAliases = _updateAlias(existingAliases, feat.name, "job");
-    });
     feats.workflow.forEach((feat) => {
         existingAliases = _updateAlias(existingAliases, feat.name, "workflow");
     });
@@ -71,11 +69,19 @@ function upsertAndCleanFeatures(feats, type) {
     const rows = stmt.all();
     const names = rows.map(row => row.name);
     const availableFeatsNames = feats.map((f) => f.name);
+    const newFeatures = new Array();
     names.forEach((name) => {
         if (!availableFeatsNames.includes(name)) {
             const deleteStmt = db.prepare(`DELETE FROM ${type} WHERE name = ?`);
             deleteStmt.run(name);
             console.log("-", "[" + type + "]", name);
+            const stmt1 = db.prepare("SELECT * FROM tool WHERE name = ?");
+            const result = stmt1.get(name);
+            if (result?.id) {
+                const deleteStmt = db.prepare("DELETE FROM featurespath WHERE id = ?");
+                deleteStmt.run(result.id);
+                console.log("-", "[tool] from", type, ":", name);
+            }
         }
     });
     feats.forEach((feat) => {
@@ -83,14 +89,34 @@ function upsertAndCleanFeatures(feats, type) {
             const insertStmt = db.prepare(`INSERT INTO ${type} (name, path, ext) VALUES (?, ?, ?)`);
             insertStmt.run(feat.name, feat.path, feat.ext);
             console.log("+", "[" + type + "]", feat.name, feat.path);
+            newFeatures.push(feat);
         }
     });
+    return newFeatures;
+}
+function upsertTool(name, type, toolDoc) {
+    const stmt1 = db.prepare("SELECT * FROM tool WHERE name = ?");
+    const result = stmt1.get(name);
+    if (result?.id) {
+        return;
+    }
+    const stmt = db.prepare("INSERT INTO tool (name, spec, type) VALUES (?,?,?)");
+    stmt.run(name, toolDoc, type);
+    console.log("+", "[tool] from", type, ":", name);
 }
 function updateFeatures(feats) {
     upsertAndCleanFeatures(feats.task, "task");
-    upsertAndCleanFeatures(feats.job, "job");
-    upsertAndCleanFeatures(feats.action, "action");
+    const newActions = upsertAndCleanFeatures(feats.action, "action");
+    if (newActions.length > 0) {
+        newActions.forEach((feat) => {
+            const { found, toolDoc } = extractToolDoc(feat.name, feat.ext, feat.path);
+            if (found) {
+                upsertTool(feat.name, "action", toolDoc);
+            }
+        });
+    }
     upsertAndCleanFeatures(feats.cmd, "cmd");
     upsertAndCleanFeatures(feats.workflow, "workflow");
+    upsertAndCleanFeatures(feats.adaptater, "adaptater");
 }
 export { updatePromptfilePath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, };