@agent-smith/core 0.0.1

package/dist/conf.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import path from "node:path";
+import { homedir } from 'os';
+import { join } from 'path';
+import yaml from "yaml";
+import { runtimeError } from "./utils/user_msgs.js";
+import { createDirectoryIfNotExists } from "./utils/sys/dirs.js";
+import { readConf } from "./utils/sys/read_conf.js";
+import { deleteAgentSettings, insertFeaturesPathIfNotExists, insertPluginIfNotExists, upsertAndCleanWorkspaces, upsertBackends, upsertAgentSettings } from "./db/write.js";
+import { buildPluginsPaths } from "./state/plugins.js";
+import { initAgentSettings, agentSettings } from "./state/tasks.js";
+function getConfigPath(appName, filename) {
+    let confDir;
+    let dbPath;
+    if (process.platform === 'win32') {
+        confDir = join(process.env.APPDATA, appName);
+        dbPath = join(process.env.APPDATA, appName, filename);
+    }
+    else if (process.platform === 'darwin') {
+        confDir = join(homedir(), 'Library', 'Application Support', appName);
+        dbPath = join(homedir(), 'Library', 'Application Support', appName, filename);
+    }
+    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");
+function updateConfigFile(conf, cfp) {
+    const fp = cfp ? cfp : path.join(confDir, "config.yml");
+    const txt = yaml.stringify(conf);
+    if (!fs.existsSync(fp)) {
+        const err = `Config file ${fp} does not exist`;
+        throw new Error(err);
+    }
+    try {
+        fs.writeFileSync(fp, txt, { encoding: 'utf8' });
+    }
+    catch (e) {
+        throw new Error(`Error creating config file at ${fp}: ${e}`);
+    }
+    return fp;
+}
+function createConfigFileIfNotExists(cfp) {
+    const fp = cfp ? cfp : path.join(confDir, "config.yml");
+    if (fs.existsSync(fp)) {
+        return fp;
+    }
+    createDirectoryIfNotExists(confDir);
+    console.log("Creating config file", fp);
+    const fc = {
+        backends: {
+            default: "llamacpp",
+            llamacpp: {
+                url: "http://localhost:8080/v1"
+            }
+        },
+        promptfile: "",
+    };
+    const txt = yaml.stringify(fc);
+    try {
+        fs.writeFileSync(fp, txt, { encoding: 'utf8' });
+    }
+    catch (e) {
+        throw new Error(`Error creating config file at ${fp}: ${e}`);
+    }
+    return fp;
+}
+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) {
+        for (const [name, val] of Object.entries(data.backends)) {
+            switch (name) {
+                case "default":
+                    const v1 = val;
+                    defaultBackendName = v1;
+                    break;
+                default:
+                    const v3 = val;
+                    let apiKey = undefined;
+                    if (v3?.apiKey) {
+                        apiKey = v3.apiKey;
+                    }
+                    const ib = {
+                        name: name,
+                        type: v3.type,
+                        url: v3.url,
+                        isDefault: false,
+                    };
+                    if (apiKey) {
+                        ib.apiKey = apiKey;
+                    }
+                    backends[name] = ib;
+                    break;
+            }
+        }
+    }
+    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();
+        data.features.forEach((f) => {
+            if (!fts.includes(f)) {
+                insertFeaturesPathIfNotExists(f);
+                fts.push(f);
+            }
+        });
+    }
+    if (data?.plugins) {
+        const plugins = await buildPluginsPaths(data.plugins);
+        plugins.forEach((_pl) => {
+            allPaths.push(_pl.path);
+            insertPluginIfNotExists(_pl.name, _pl.path);
+        });
+    }
+    if (data?.agents) {
+        initAgentSettings();
+        const okAgents = new Array();
+        for (const [name, settings] of Object.entries(data.agents)) {
+            upsertAgentSettings(name, settings);
+            okAgents.push(name);
+        }
+        const toDel = Object.keys(agentSettings).filter(t => !okAgents.includes(t));
+        deleteAgentSettings(toDel);
+    }
+    if (data?.workspaces) {
+        const wsd = new Array();
+        for (const [k, v] of Object.entries(data.workspaces)) {
+            wsd.push({ name: k, path: v, props: {} });
+        }
+        upsertAndCleanWorkspaces(wsd);
+    }
+    let pf = "";
+    if (data?.promptfile) {
+        pf = data.promptfile;
+    }
+    let dd = "";
+    if (data?.datadir) {
+        dd = data.datadir;
+    }
+    return { paths: allPaths, pf: pf, dd: dd };
+}
+export { confDir, createConfigFileIfNotExists, dbPath, getConfigPath, processConfPath, updateConfigFile };

package/dist/const.d.ts

@@ -0,0 +1,3 @@
+import { InferenceBackend } from "@agent-smith/types";
+declare const localBackends: Record<string, InferenceBackend>;
+export { localBackends };

package/dist/const.js

@@ -0,0 +1,10 @@
+const localBackends = {
+    llamacpp: {
+        name: "llamacpp",
+        type: "openai",
+        url: "http://localhost:8080/v1",
+        apiKey: "",
+        isDefault: true,
+    },
+};
+export { localBackends };

package/dist/db/db.d.ts

@@ -0,0 +1,3 @@
+declare let db: any;
+declare function initDb(isVerbose: boolean, execSchema: boolean): void;
+export { db, initDb, };

package/dist/db/db.js

@@ -0,0 +1,24 @@
+// @ts-ignore
+import DatabaseConstructor from "better-sqlite3";
+import { schemas } from "./schemas.js";
+import { createDirectoryIfNotExists } from "../utils/sys/dirs.js";
+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 });
+        schemas.forEach((s) => {
+            db.exec(s);
+            if (isVerbose) {
+                console.log(`Schema executed: ${s}`);
+            }
+        });
+    }
+    else {
+        db = new DatabaseConstructor(dbPath, { fileMustExist: true });
+    }
+}
+export { db, initDb, };

package/dist/db/read.d.ts

@@ -0,0 +1,45 @@
+import type { AliasType, FeatureSpec, FeatureType, InferenceBackend, SamplingPreset, ToolSpec, Workspace } from "@agent-smith/types";
+declare function readFeaturePaths(): Array<string>;
+declare function readBackends(): Record<string, InferenceBackend>;
+declare function readPlugins(): Array<Record<string, string>>;
+declare function readFeaturesType(type: FeatureType, innerType?: string, names?: Array<string>): Record<string, FeatureSpec>;
+declare function readAllSkills(): Record<string, FeatureSpec>;
+declare function readSkillsFromList(names: Array<string>): Record<string, FeatureSpec>;
+declare function readFeatures(): Record<FeatureType, Record<string, FeatureSpec>>;
+declare function readAliases(): Array<{
+    name: string;
+    type: AliasType;
+}>;
+declare function readFeature(name: string, type: FeatureType, innerType?: string): {
+    found: boolean;
+    feature: FeatureSpec;
+};
+declare function readTool(name: string): {
+    found: boolean;
+    tool: ToolSpec;
+};
+declare function readFilePaths(): Array<{
+    name: string;
+    path: string;
+}>;
+declare function readFilePath(name: string): {
+    found: boolean;
+    path: string;
+};
+declare function readAgentSettings(): Array<Record<string, any>>;
+declare function readAgentSetting(name: string): {
+    found: boolean;
+    settings: Record<string, string>;
+};
+declare function readWorkspaces(): Array<Workspace>;
+declare function readSetting(name: string): {
+    found: boolean;
+    setting: string;
+};
+declare function readSettings(): Record<string, any>;
+declare function readSamplingPreset(name: string): {
+    found: boolean;
+    preset: SamplingPreset;
+};
+declare function readSamplingPresets(): Array<SamplingPreset>;
+export { readAgentSettings, readAliases, readBackends, readFeature, readFeaturePaths, readFeatures, readFeaturesType, readFilePath, readFilePaths, readPlugins, readSetting, readSettings, readSkillsFromList, readAgentSetting, readTool, readWorkspaces, readSamplingPreset, readSamplingPresets, readAllSkills, };

package/dist/db/read.js

@@ -0,0 +1,280 @@
+import { db } from "./db.js";
+function readFeaturePaths() {
+    const stmt = db.prepare("SELECT path FROM featurespath");
+    const data = stmt.all();
+    let f = new Array();
+    data.forEach((row) => {
+        f.push(row.path);
+    });
+    return f;
+}
+function readBackends() {
+    const stmt = db.prepare("SELECT name, type, url, apiKey, isdefault FROM backend");
+    const data = stmt.all();
+    const bks = {};
+    data.forEach((row) => {
+        bks[row.name] = { name: row.name, type: row.type, url: row.url, apiKey: row.apiKey, isDefault: row.isdefault === 1 };
+    });
+    return bks;
+}
+function readPlugins() {
+    const stmt = db.prepare("SELECT name, path FROM plugin");
+    const data = stmt.all();
+    let f = new Array();
+    data.forEach((row) => {
+        f.push({ name: row.name, path: row.path });
+    });
+    return f;
+}
+function readFeaturesType(type, innerType, names) {
+    let q = `SELECT name, path, ext, variables FROM ${type}`;
+    if (type == "agent") {
+        q = `SELECT name, path, ext, variables, type, category FROM ${type}`;
+    }
+    if (innerType) {
+        q += ` WHERE type = '${innerType}'`;
+    }
+    if (names) {
+        if (innerType) {
+            q += " AND";
+        }
+        else {
+            q += " WHERE";
+        }
+        let nqb = new Array();
+        names.forEach(n => nqb.push(`'${n}'`));
+        q += ` name IN (${nqb.join(",")})`;
+    }
+    //console.log("Q", q);
+    let stmt = db.prepare(q);
+    const data = stmt.all();
+    const res = {};
+    data.forEach((row) => {
+        const vars = row?.variables ? JSON.parse(row.variables) : undefined;
+        res[row.name] = {
+            name: row.name,
+            path: row.path,
+            ext: row.ext,
+            variables: vars,
+        };
+        if (type) {
+            res[row.name].type = row.type;
+            res[row.name].category = row.category;
+        }
+    });
+    return res;
+}
+/*function readSkill(name: string): { found: boolean, feature: FeatureSpec } {
+    const q = `SELECT name, path, ext, variables FROM skill WHERE name='${name}`;
+    const stmt = db.prepare(q);
+    const result = stmt.get() as Record<string, string>;
+    let res: FeatureSpec;
+    if (result?.id) {
+        const vars = result?.variables ? JSON.parse(result.variables) as Record<string, any> : {};
+        res = {
+            name: result.name,
+            path: result.path,
+            ext: result.ext as FeatureExtension,
+            variables: vars,
+        };
+        return { found: true, feature: res }
+    }
+    return { found: false, feature: {} as FeatureSpec }
+}*/
+function readAllSkills() {
+    const q = `SELECT name, path, ext, variables FROM skill`;
+    const stmt = db.prepare(q);
+    const data = stmt.all();
+    const res = {};
+    data.forEach((row) => {
+        const vars = row?.variables ? JSON.parse(row.variables) : {};
+        res[row.name] = {
+            name: row.name,
+            path: row.path,
+            ext: row.ext,
+            variables: vars,
+        };
+    });
+    return res;
+}
+function readSkillsFromList(names) {
+    if (names.length === 0)
+        return {};
+    const placeholders = names.map(() => '?').join(',');
+    const q = `SELECT name, path, ext, variables FROM skill WHERE name IN (${placeholders})`;
+    const stmt = db.prepare(q);
+    const data = stmt.all(...names);
+    const res = {};
+    data.forEach((row) => {
+        const vars = row?.variables ? JSON.parse(row.variables) : {};
+        res[row.name] = {
+            name: row.name,
+            path: row.path,
+            ext: row.ext,
+            variables: vars,
+        };
+    });
+    return res;
+}
+function readFeatures() {
+    const feats = {
+        action: {}, cmd: {}, workflow: {}, adaptater: {}, agent: {}, skill: {}
+    };
+    feats.agent = readFeaturesType("agent");
+    feats.action = readFeaturesType("action");
+    feats.cmd = readFeaturesType("cmd");
+    feats.workflow = readFeaturesType("workflow");
+    feats.adaptater = readFeaturesType("adaptater");
+    feats.skill = readFeaturesType("skill");
+    return feats;
+}
+function readAliases() {
+    const stmt = db.prepare("SELECT name, type FROM aliases");
+    const data = stmt.all();
+    let f = new Array();
+    data.forEach((row) => {
+        f.push({ name: row.name, type: row.type });
+    });
+    return f;
+}
+function readFeature(name, type, innerType) {
+    let q = `SELECT id, name, path, ext, variables FROM ${type} WHERE name='${name}'`;
+    if (innerType) {
+        q = q + ` AND type = '${innerType}'`;
+    }
+    const stmt = db.prepare(q);
+    const result = stmt.get();
+    if (result?.id) {
+        return {
+            found: true,
+            feature: {
+                name: result.name,
+                path: result.path,
+                ext: result.ext,
+                variables: result.variables ? JSON.parse(result.variables) : undefined,
+            }
+        };
+    }
+    return { found: false, feature: {} };
+}
+function readTool(name) {
+    const q = `SELECT id, name, type, spec FROM tool WHERE name='${name}'`;
+    const stmt = db.prepare(q);
+    const result = stmt.get();
+    //console.log("db tool", result);
+    if (result?.id) {
+        const tool = JSON.parse(result.spec);
+        tool.type = result.type;
+        return {
+            found: true,
+            tool: tool,
+        };
+    }
+    return { found: false, tool: {} };
+}
+function readFilePaths() {
+    const stmt1 = db.prepare("SELECT name, path FROM filepath");
+    const data = stmt1.all();
+    let f = new Array();
+    data.forEach((row) => {
+        f.push({ name: row.name, path: row.path });
+    });
+    return f;
+}
+function readFilePath(name) {
+    const q = `SELECT id, path FROM filepath WHERE name= ?`;
+    const stmt = db.prepare(q);
+    const result = stmt.get(name);
+    if (result?.id) {
+        return { found: true, path: result.path };
+    }
+    return { found: false, path: "" };
+}
+function readAgentSettings() {
+    const stmt1 = db.prepare("SELECT * FROM agentsettings ORDER BY name");
+    const data = stmt1.all();
+    return data;
+}
+function readAgentSetting(name) {
+    const q = "SELECT * FROM agentsettings WHERE name= ?";
+    const stmt = db.prepare(q);
+    const result = stmt.get(name);
+    if (result?.id) {
+        return { found: true, settings: result };
+    }
+    return { found: false, settings: {} };
+}
+function readWorkspaces() {
+    const stmt1 = db.prepare("SELECT * FROM workspace ORDER BY name");
+    const data = stmt1.all();
+    const wss = new Array();
+    data.forEach(row => wss.push({ name: row.name, path: row.path, props: row.props }));
+    return wss;
+}
+function readSetting(name) {
+    const q = "SELECT * FROM setting WHERE name= ?";
+    const stmt = db.prepare(q);
+    const result = stmt.get(name);
+    if (result?.id) {
+        return { found: true, setting: result };
+    }
+    return { found: false, setting: "" };
+}
+function readSettings() {
+    const q = "SELECT name, value FROM setting";
+    const stmt = db.prepare(q);
+    const result = stmt.all();
+    const st = {};
+    result.forEach(row => st[row.name] = row.value);
+    return st;
+}
+function readSamplingPreset(name) {
+    const q = "SELECT * FROM modelpreset WHERE name= ?";
+    const stmt = db.prepare(q);
+    const result = stmt.get(name);
+    if (result?.id) {
+        return {
+            found: true,
+            preset: {
+                name: result.name,
+                model: result.model,
+                max_tokens: result.max_tokens,
+                top_k: result.top_k,
+                top_p: result.top_p,
+                min_p: result.min_p,
+                temperature: result.temperature,
+                repeat_penalty: result.repeat_penalty,
+                presence_penalty: result.presence_penalty,
+                frequency_penalty: result.frequency_penalty,
+                backend: result.backend,
+                chat_template_kwargs: JSON.parse(result.chat_template_kwargs),
+                props: JSON.parse(result.props)
+            }
+        };
+    }
+    return { found: false, preset: {} };
+}
+function readSamplingPresets() {
+    const stmt1 = db.prepare("SELECT * FROM modelpreset ORDER BY name");
+    const data = stmt1.all();
+    const presets = new Array();
+    data.forEach(row => presets.push({
+        name: row.name,
+        model: row.model,
+        max_tokens: row.max_tokens,
+        top_k: row.top_k,
+        top_p: row.top_p,
+        min_p: row.min_p,
+        temperature: row.temperature,
+        repeat_penalty: row.repeat_penalty,
+        presence_penalty: row.presence_penalty,
+        frequency_penalty: row.frequency_penalty,
+        backend: row.backend,
+        chat_template_kwargs: JSON.parse(row.chat_template_kwargs),
+        props: JSON.parse(row.props)
+    }));
+    return presets;
+}
+export { readAgentSettings, readAliases, readBackends, readFeature, readFeaturePaths, readFeatures, readFeaturesType, readFilePath, readFilePaths, readPlugins, readSetting, readSettings, readSkillsFromList, readAgentSetting, readTool, readWorkspaces, readSamplingPreset, readSamplingPresets, readAllSkills,
+//readSkill
+ };

package/dist/db/schemas.d.ts

@@ -0,0 +1,2 @@
+declare const schemas: string[];
+export { schemas };

package/dist/db/schemas.js

@@ -0,0 +1,141 @@
+const filepath = `CREATE TABLE IF NOT EXISTS filepath (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL
+);`;
+const featurespath = `CREATE TABLE IF NOT EXISTS featurespath (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL
+);`;
+const plugin = `CREATE TABLE IF NOT EXISTS plugin (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL
+);`;
+const agents = `CREATE TABLE IF NOT EXISTS agent (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml') ),
+    type TEXT,
+    category TEXT
+);`;
+const workflow = `CREATE TABLE IF NOT EXISTS workflow (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml') ),
+    type TEXT,
+    category TEXT
+);`;
+const action = `CREATE TABLE IF NOT EXISTS action (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
+);`;
+const adaptater = `CREATE TABLE IF NOT EXISTS adaptater (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
+);`;
+const skill = `CREATE TABLE IF NOT EXISTS skill (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    ext TEXT NOT NULL CHECK ( ext IN ('md') )
+);`;
+const cmd = `CREATE TABLE IF NOT EXISTS cmd (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    variables TEXT,
+    ext TEXT NOT NULL CHECK ( ext IN ('js') )
+);`;
+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 ('agent', 'task', 'action', 'workflow') )
+);`;
+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 ('agent', 'task', 'action', 'workflow') )
+);`;
+const backend = `CREATE TABLE IF NOT EXISTS backend (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    type TEXT CHECK ( type IN ('browser', 'openai') ),
+    url TEXT NOT NULL,
+    isdefault INTEGER NOT NULL,
+    apiKey TEXT
+);`;
+const agentSettings = `CREATE TABLE IF NOT EXISTS agentsettings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    model TEXT,
+    max_tokens INTEGER,
+    top_k INTEGER,
+    top_p REAL,
+    min_p REAL,
+    temperature REAL,
+    repeat_penalty REAL,
+    presence_penalty REAL,
+    frequency_penalty REAL,
+    backend TEXT,
+    chat_template_kwargs TEXT,
+    props TEXT
+);`;
+const workspace = `CREATE TABLE IF NOT EXISTS workspace (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    props TEXT
+);`;
+const setting = `CREATE TABLE IF NOT EXISTS setting (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    value TEXT NOT NULL
+);`;
+const samplingPresets = `CREATE TABLE IF NOT EXISTS modelpreset (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    model TEXT,
+    max_tokens INTEGER,
+    top_k INTEGER,
+    top_p REAL,
+    min_p REAL,
+    temperature REAL,
+    repeat_penalty REAL,
+    presence_penalty REAL,
+    frequency_penalty REAL,
+    backend TEXT,
+    chat_template_kwargs TEXT,
+    props TEXT
+);`;
+const schemas = [
+    filepath,
+    featurespath,
+    workflow,
+    action,
+    tool,
+    cmd,
+    plugin,
+    alias,
+    adaptater,
+    backend,
+    agentSettings,
+    agents,
+    workspace,
+    setting,
+    skill,
+    samplingPresets,
+];
+export { schemas };