@agent-smith/core 0.0.1

package/dist/mcp.js

@@ -0,0 +1,110 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+//import { confirmToolUsage } from "./tools.js";
+class McpClient {
+    name;
+    transport;
+    client;
+    authorizedTools = null;
+    askUserTools = null;
+    tools = {};
+    constructor(servername, command, args, authorizedTools = null, askUserTools = null) {
+        //console.log("MCP servername", servername);
+        //console.log("MCP command", command);
+        //console.log("MCP ARGS", typeof args, args);
+        this.name = servername;
+        const okargs = new Array();
+        for (const arg of args) {
+            let _arg = arg;
+            if (arg.startsWith("Authorization:")) {
+                const k = `MCP_${servername.toUpperCase()}_AUTH`;
+                const v = process.env[k];
+                if (!v) {
+                    throw new Error(`Env variable ${k} not found for ${servername} mcp auth`);
+                }
+                _arg = arg.replace("$MCP_AUTH", v);
+            }
+            okargs.push(_arg);
+        }
+        this.transport = new StdioClientTransport({
+            command: command,
+            args: args
+        });
+        this.client = new Client({ name: "AgentSmith", version: "0.1.0" });
+        if (authorizedTools) {
+            this.authorizedTools = authorizedTools;
+        }
+        if (askUserTools) {
+            this.askUserTools = askUserTools;
+        }
+    }
+    async start() {
+        await this.client.connect(this.transport);
+    }
+    async stop() {
+        await this.client.close();
+    }
+    async extractTools(options) {
+        const toolSpecs = new Array();
+        const serverToolsList = await this.client.listTools();
+        for (const tool of serverToolsList.tools) {
+            if (this.authorizedTools) {
+                if (!this.authorizedTools.includes(tool.name)) {
+                    continue;
+                }
+            }
+            const defargs = {};
+            const argsTypes = {};
+            if (tool.inputSchema.properties) {
+                for (const [k, v] of Object.entries(tool.inputSchema.properties)) {
+                    const vv = v;
+                    defargs[k] = { description: vv.description + " (" + vv.type + ")" };
+                    argsTypes[k] = vv.type;
+                }
+            }
+            //console.log("MCP ARGS TYPES", argsTypes);
+            const exec = async (args) => {
+                //console.log("MCP EXEC ARGS", args);
+                const _iargs = args;
+                for (const [k, v] of Object.entries(_iargs)) {
+                    if (argsTypes[k] == "array") {
+                        try {
+                            _iargs[k] = JSON.parse(v);
+                        }
+                        catch (e) {
+                            console.warn("Error parsing array data from model for tool call", k, "Data:", v);
+                        }
+                    }
+                }
+                ;
+                const payload = {
+                    name: tool.name,
+                    arguments: _iargs,
+                };
+                //console.log("PAY", payload);
+                const res = await this.client.callTool(payload);
+                return res;
+            };
+            const t = {
+                type: "mcp",
+                name: tool.name,
+                description: tool.description ?? "",
+                arguments: defargs,
+                parallelCalls: true,
+                execute: exec
+            };
+            if (this.askUserTools) {
+                if (this.askUserTools.includes(tool.name)) {
+                    if (!options?.confirmToolUsage) {
+                        throw new Error("provide a tool usage confirm function");
+                    }
+                    t.canRun = options.confirmToolUsage;
+                }
+            }
+            this.tools[tool.name] = t;
+            toolSpecs.push(t);
+        }
+        return toolSpecs;
+    }
+}
+export { McpClient, };

package/dist/state/backends.d.ts

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

package/dist/state/backends.js

@@ -0,0 +1,96 @@
+import { Lm } from "@agent-smith/agent";
+import { ref } from "@vue/reactivity";
+import colors from "ansi-colors";
+import { readBackends } from "../db/read.js";
+import { setDefaultBackend } from "../db/write.js";
+import { runtimeDataError } from "../utils/user_msgs.js";
+const backend = ref();
+const backends = {};
+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) {
+            if (bk.apiKey.startsWith("$")) {
+                const apk = process.env[bk.apiKey.slice(1)];
+                if (apk === undefined) {
+                    runtimeDataError(`No ${bk.apiKey} environment variable found, required for `, name);
+                    return;
+                }
+                apiKey = apk;
+            }
+            else {
+                apiKey = bk.apiKey;
+            }
+        }
+        ;
+        const lm = new Lm({
+            name: name,
+            serverUrl: bk.url,
+            apiKey: apiKey.length > 0 ? apiKey : undefined,
+        });
+        lm.name = bk.name;
+        //console.log("ADD BK", lm);
+        backends[name] = lm;
+        if (bk.isDefault) {
+            defaultBackendName = bk.name;
+        }
+    }
+    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) {
+    if (!(Object.keys(backends).includes(name))) {
+        runtimeDataError(`Backend ${name} not found. Available backends: ${Object.keys(backends)}`);
+        return false;
+    }
+    backend.value = backends[name];
+    setDefaultBackend(name);
+    console.log("Default backend set to", name);
+    isBackendUp.value = await probeBackend(backend.value, isVerbose);
+    return isBackendUp.value;
+}
+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.serverUrl));
+        const str = buf.join(" ");
+        if (printResult) {
+            console.log(str);
+        }
+        allBk.push(str);
+    }
+    return allBk.join(" ");
+}
+const probeBackend = async (lm, isVerbose) => {
+    let isUp = false;
+    try {
+        await lm.modelsInfo();
+        if (isVerbose) {
+            console.log(`Provider ${lm.name} up`);
+        }
+        isUp = true;
+    }
+    catch (e) {
+        if (isVerbose) {
+            console.log(`Provider ${lm.name} down`, e);
+        }
+    }
+    return isUp;
+};
+export { backend, backends, initBackends, listBackends, setBackend };

package/dist/state/features.d.ts

@@ -0,0 +1,10 @@
+import { FeatureExtension, FeatureType, Features } from "@agent-smith/types";
+declare function getBuiltinFeaturesDirPath(): string;
+declare function readFeaturesDirs(featuresPaths: Array<string>, isverbose?: boolean): Features;
+declare function getFeatureSpec(name: string, type: FeatureType): {
+    found: boolean;
+    path: string;
+    ext: FeatureExtension;
+    variables?: Record<string, any>;
+};
+export { readFeaturesDirs, getFeatureSpec, getBuiltinFeaturesDirPath, };

package/dist/state/features.js

@@ -0,0 +1,42 @@
+import { default as path } from "path";
+import { readFeaturesDir } from "../utils/sys/read_features.js";
+import { readFeature } from "../db/read.js";
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+function getBuiltinFeaturesDirPath() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    return join(__dirname, "../features");
+}
+function readFeaturesDirs(featuresPaths, isverbose = false) {
+    const feats = {
+        action: [],
+        cmd: [],
+        workflow: [],
+        adaptater: [],
+        agent: [],
+        skill: [],
+    };
+    featuresPaths.forEach((dir) => {
+        if (isverbose) {
+            console.log("Reading feats in", dir);
+        }
+        const _f = readFeaturesDir(dir);
+        _f.agent.forEach((item) => feats.agent.push(item));
+        _f.action.forEach((item) => feats.action.push(item));
+        _f.cmd.forEach((item) => feats.cmd.push(item));
+        _f.workflow.forEach((item) => feats.workflow.push(item));
+        _f.adaptater.forEach((item) => feats.adaptater.push(item));
+        _f.skill.forEach((item) => feats.skill.push(item));
+    });
+    return feats;
+}
+function getFeatureSpec(name, type) {
+    const { found, feature } = readFeature(name, type);
+    if (!found) {
+        return { found: false, path: "", ext: "yml", variables: {} };
+    }
+    const f = path.join(feature.path, name + "." + feature.ext);
+    return { found: true, path: f, ext: feature.ext, variables: feature?.variables };
+}
+export { readFeaturesDirs, getFeatureSpec, getBuiltinFeaturesDirPath, };

package/dist/state/plugins.d.ts

@@ -0,0 +1,6 @@
+declare function buildPluginsPaths(names: Array<string>): Promise<Array<{
+    name: string;
+    path: string;
+}>>;
+declare function readPluginsPaths(): Promise<Array<string>>;
+export { buildPluginsPaths, readPluginsPaths };

package/dist/state/plugins.js

@@ -0,0 +1,27 @@
+import { execute } from "../utils/sys/execute.js";
+import { readPlugins } from "../db/read.js";
+import path from "path";
+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() {
+    const paths = new Array();
+    const plugins = readPlugins();
+    plugins.forEach((p) => {
+        paths.push(p.path);
+    });
+    //console.log("PLUGINS PATHS", paths);
+    return paths;
+}
+export { buildPluginsPaths, readPluginsPaths };

package/dist/state/state.d.ts

@@ -0,0 +1,18 @@
+import { FormatMode, InputMode, OutputMode } from "@agent-smith/types";
+import { PythonShell } from 'python-shell';
+declare let pyShell: PythonShell;
+declare const inputMode: import("@vue/reactivity").Ref<InputMode, InputMode>;
+declare const outputMode: import("@vue/reactivity").Ref<OutputMode, OutputMode>;
+declare const formatMode: import("@vue/reactivity").Ref<FormatMode, FormatMode>;
+declare const promptfilePath: import("@vue/reactivity").Ref<string, string>;
+declare const dataDirPath: import("@vue/reactivity").Ref<string, string>;
+declare const isStateReady: import("@vue/reactivity").Ref<boolean, boolean>;
+declare const lastCmd: {
+    name: string;
+    args: Array<string>;
+};
+declare function initFilepaths(): void;
+declare function init(): Promise<void>;
+declare function initState(): Promise<void>;
+declare function pluginDataDir(pluginName: string): string;
+export { dataDirPath, formatMode, init, initFilepaths, initState, inputMode, isStateReady, lastCmd, outputMode, pluginDataDir, promptfilePath, pyShell };

package/dist/state/state.js

@@ -0,0 +1,79 @@
+import { reactive, ref } from "@vue/reactivity";
+import path from "path";
+import { createDirectoryIfNotExists } from "../utils/sys/dirs.js";
+import { initDb } from "../db/db.js";
+import { readFilePaths } from "../db/read.js";
+import { runtimeDataError } from "../utils/user_msgs.js";
+import { backend, initBackends } from "./backends.js";
+//import { usePerfTimer } from "../main.js";
+let pyShell;
+const inputMode = ref("manual");
+const outputMode = ref("txt");
+const formatMode = ref("text");
+//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":
+                promptfilePath.value = fp.path;
+                break;
+            case "datadir":
+                dataDirPath.value = fp.path;
+        }
+    }
+}
+async function init() {
+    if (isStateReady.value) {
+        return;
+    }
+    //const perf = usePerfTimer();
+    await initState();
+    //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) {
+        throw new Error("datadir path is not configured: update your config file with 'datadir' and run conf");
+    }
+    return dataDirPath.value;
+}
+function pluginDataDir(pluginName) {
+    const dd = _getDataDirPath();
+    const pluginDatapath = path.join(dd, pluginName);
+    createDirectoryIfNotExists(pluginDatapath);
+    return pluginDatapath;
+}
+/*function setVerbosity(mode: VerbosityMode) {
+    verbosity.value = mode
+}*/
+export { dataDirPath, formatMode, init, initFilepaths, initState, inputMode, isStateReady, lastCmd, outputMode, pluginDataDir, promptfilePath, pyShell };

package/dist/state/tasks.d.ts

@@ -0,0 +1,6 @@
+import { AgentSettings } from "@agent-smith/types";
+declare const agentSettings: Record<string, AgentSettings>;
+declare const isAgentSettingsInitialized: import("@vue/reactivity").Ref<boolean, boolean>;
+declare function initAgentSettings(): void;
+declare function getAgentSettings(force?: boolean): Record<string, AgentSettings>;
+export { agentSettings, isAgentSettingsInitialized, initAgentSettings, getAgentSettings };

package/dist/state/tasks.js

@@ -0,0 +1,33 @@
+import { ref } from "@vue/reactivity";
+import { readAgentSettings } from "../db/read.js";
+const agentSettings = {};
+const isAgentSettingsInitialized = ref(false);
+function initAgentSettings() {
+    const data = readAgentSettings();
+    //console.log("AGENT SETTINGS DATA", data);
+    data.forEach(row => {
+        const name = row.name;
+        delete row.name;
+        delete row.id;
+        const vals = {};
+        for (const [k, v] of Object.entries(row)) {
+            if (v !== null) {
+                let _v = v;
+                if (["props", "chat_template_kwargs"].includes(k)) {
+                    _v = JSON.parse(v);
+                }
+                vals[k] = _v;
+            }
+        }
+        agentSettings[name] = vals;
+    });
+    //console.log("AGENT SETTINGS", agentSettings);
+    isAgentSettingsInitialized.value = true;
+}
+function getAgentSettings(force = false) {
+    if (!isAgentSettingsInitialized.value === true || force) {
+        initAgentSettings();
+    }
+    return agentSettings;
+}
+export { agentSettings, isAgentSettingsInitialized, initAgentSettings, getAgentSettings };

package/dist/tools.d.ts

@@ -0,0 +1,15 @@
+import type { FeatureExtension } from '@agent-smith/types';
+declare function extractAgentToolDocAndVariables(name: string, ext: FeatureExtension, dirPath: string): {
+    toolDoc: string;
+    variables: {
+        required: Array<string>;
+        optional: Array<string>;
+    };
+    type: string | null;
+    category: string | null;
+};
+declare function extractToolDoc(name: string, ext: FeatureExtension, dirPath: string): {
+    found: boolean;
+    toolDoc: string;
+};
+export { extractToolDoc, extractAgentToolDocAndVariables, };

package/dist/tools.js

@@ -0,0 +1,149 @@
+import YAML from 'yaml';
+import * as fs from 'fs';
+import { readYmlFile } from './utils/sys/read_yml_file.js';
+function _extractToolDoc(filePath, startComment, endComment) {
+    try {
+        //console.log("TD", filePath);
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        const startMarker = startComment + '\n# tool';
+        //console.log("TD 2", fileContent.startsWith(startMarker));
+        if (!fileContent.startsWith(startMarker)) {
+            //console.log("TD ERR", fileContent)
+            return { found: false, doc: "" };
+        }
+        const endMarker = endComment;
+        const startIndex = fileContent.indexOf(startMarker) + startMarker.length;
+        const endIndex = fileContent.indexOf(endMarker, startIndex);
+        if (endIndex === -1) {
+            throw new Error(`Markers not found in the file: ${filePath}`);
+        }
+        const extractedContent = fileContent.substring(startIndex, endIndex).trim();
+        //console.log("TD 3", fileContent.substring(startIndex, endIndex).trim());
+        //console.log("TD 4", extractedContent);
+        return { found: true, doc: extractedContent };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('ENOENT')) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            else {
+                throw new Error(`Error processing the file: ${filePath}. ${error.message}`);
+            }
+        }
+        else {
+            throw new Error(`An unexpected error occurred: ${error}`);
+        }
+    }
+}
+function _extractPyToolDoc(filePath) {
+    return _extractToolDoc(filePath, '"""', '"""');
+}
+function _extractJsToolDoc(filePath) {
+    return _extractToolDoc(filePath, '/*', '*/');
+}
+function _extractYamlToolDoc(filePath, name) {
+    const { data, found } = readYmlFile(filePath);
+    //console.log("_extractYamlToolDoc from", name, data?.tool);
+    if (!found) {
+        return { found: false, tspec: {} };
+    }
+    if (!data?.tool) {
+        return { found: false, tspec: {} };
+    }
+    data.tool.name = name;
+    return { found: true, tspec: data.tool };
+}
+function _parseToolDoc(rawTxt, name) {
+    try {
+        const res = YAML.parse(rawTxt);
+        res["name"] = name;
+        //console.log("PARSE TOOL DOC", res);
+        return res;
+    }
+    catch (e) {
+        throw new Error(`Error parsing tool ${name}: ${e} \nData:\n${rawTxt}\n`);
+    }
+}
+function _parseAgentVariables(data) {
+    const res = { required: new Array(), optional: new Array() };
+    if (data?.variables) {
+        if (data.variables?.required) {
+            res.required = data.variables.required;
+        }
+        if (data.variables?.optional) {
+            res.optional = data.variables.optional;
+        }
+    }
+    return res;
+}
+function extractAgentToolDocAndVariables(name, ext, dirPath) {
+    const fp = dirPath + "/" + name + "." + ext;
+    const { data, found } = readYmlFile(fp);
+    const res = { variables: { required: new Array(), optional: new Array() }, toolDoc: "", type: null, category: null };
+    // tools
+    let tspec;
+    if (!found) {
+        throw new Error(`extractAgentToolDocAndVariables: file ${fp} not found`);
+    }
+    if (data?.tool) {
+        data.tool.name = name;
+        tspec = data.tool;
+        res.toolDoc = JSON.stringify(tspec, null, "  ");
+    }
+    // variables
+    const { required, optional } = _parseAgentVariables(data);
+    res.variables.required = required;
+    res.variables.optional = optional;
+    // type
+    if (data?.type) {
+        res.type = data.type;
+    }
+    // category
+    if (data?.category) {
+        res.category = data.category;
+    }
+    return res;
+}
+function extractToolDoc(name, ext, dirPath) {
+    let spec;
+    let found = false;
+    let doc = "";
+    let docts = null;
+    switch (ext) {
+        case "py":
+            let res = _extractPyToolDoc(dirPath + "/" + name + "." + ext);
+            found = res.found;
+            doc = res.doc;
+            break;
+        case "js":
+            let res2 = _extractJsToolDoc(dirPath + "/" + name + "." + ext);
+            found = res2.found;
+            doc = res2.doc;
+            break;
+        case "yml":
+            let res3 = _extractYamlToolDoc(dirPath + "/" + name + "." + ext, name);
+            found = res3.found;
+            docts = res3.tspec;
+            break;
+        default:
+            return { found: false, toolDoc: "" };
+        //throw new Error(`Unknown tool doc feature type`)        
+    }
+    if (found) {
+        let ts;
+        if (docts) {
+            ts = docts;
+        }
+        else {
+            ts = _parseToolDoc(doc, name);
+        }
+        spec = JSON.stringify(ts, null, "  ");
+        //console.log("PARSE TOOL", name, spec);
+    }
+    else {
+        return { found: false, toolDoc: "" };
+    }
+    return { found: true, toolDoc: spec };
+}
+export { extractToolDoc, extractAgentToolDocAndVariables, };

package/dist/updateconf.d.ts

@@ -0,0 +1,5 @@
+import type { Features } from "@agent-smith/types";
+declare function updateFeaturesCmd(options: Record<string, any>, userFeats?: Features): Promise<any>;
+declare function recreateDbFromConf(): Promise<void>;
+declare function updateConfCmd(args: Array<string>): Promise<any>;
+export { updateConfCmd, updateFeaturesCmd, recreateDbFromConf, };