@agent-smith/core 0.0.1

package/dist/updateconf.js

@@ -0,0 +1,124 @@
+import path from "path";
+import { confDir, createConfigFileIfNotExists, dbPath, processConfPath } from "./conf.js";
+import { initDb } from "./db/db.js";
+import { readFeaturePaths, readFilePath } from "./db/read.js";
+import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, updatePromptfilePath, upsertFilePath } from "./db/write.js";
+import { getBuiltinFeaturesDirPath, readFeaturesDirs } from "./state/features.js";
+import { readPluginsPaths } from "./state/plugins.js";
+import { dataDirPath, promptfilePath } from "./state/state.js";
+//import { runtimeDataError, runtimeInfo } from './user_msgs.js';
+import { readUserCmd } from "./utils/sys/read_cmds.js";
+import { deleteFileIfExists } from "./utils/sys/delete_file.js";
+async function getUserCmdsData(feats) {
+    for (const feat of feats.cmd) {
+        const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
+        const { found, userCmd } = await readUserCmd(feat.name, cmdPath);
+        //console.log("READ CMD", userCmd);
+        if (!userCmd?.name) {
+            throw new Error(`provide a name for the ${feat.path} command`);
+        }
+        if (!userCmd?.description) {
+            throw new Error(`provide a description for the ${feat.path} command`);
+        }
+        if (found) {
+            feat.variables = {
+                description: userCmd.description,
+                name: userCmd.name,
+            };
+            if (userCmd?.options) {
+                feat.variables.options = userCmd.options;
+            }
+        }
+    }
+    return feats;
+}
+async function updateAllFeatures(paths, userFeats) {
+    //console.log("updateAllFeatures", paths);
+    const p = [getBuiltinFeaturesDirPath(), ...paths];
+    let feats = readFeaturesDirs(p, true);
+    feats = await getUserCmdsData(feats);
+    if (userFeats?.action) {
+        feats.action.push(...userFeats.action);
+    }
+    if (userFeats?.adaptater) {
+        feats.adaptater.push(...userFeats.adaptater);
+    }
+    if (userFeats?.agent) {
+        feats.agent.push(...userFeats.agent);
+    }
+    if (userFeats?.cmd) {
+        feats.cmd.push(...userFeats.cmd);
+    }
+    if (userFeats?.workflow) {
+        feats.workflow.push(...userFeats.workflow);
+    }
+    if (userFeats?.skill) {
+        feats.skill.push(...userFeats.skill);
+    }
+    updateFeatures(feats);
+    updateAliases(feats);
+    const deleted = cleanupFeaturePaths(paths);
+    for (const el of deleted) {
+        console.log("- [feature path]", el);
+    }
+}
+async function updateFeaturesCmd(options, userFeats) {
+    const fp = readFeaturePaths();
+    const pp = await readPluginsPaths();
+    const paths = [...fp, ...pp];
+    updateAllFeatures(paths, userFeats);
+}
+async function recreateDbFromConf() {
+    // try to find a conf path in db
+    let confPath;
+    const cf = readFilePath("conf");
+    if (cf.found) {
+        confPath = cf.path;
+    }
+    else {
+        // use default conf path
+        confPath = path.join(confDir, "config.yml");
+    }
+    console.log("Deleting db");
+    deleteFileIfExists(dbPath);
+    console.log("Using", confPath, "to recreate the db");
+    await updateConfCmd([confPath]);
+    console.log(`Config recreated db ${dbPath} from ${confPath} ok`);
+}
+async function updateConfCmd(args) {
+    initDb(false, true);
+    let confPath;
+    const userProvidedConfPath = (args[0] != "conf") ? args[0] : null;
+    if (userProvidedConfPath) {
+        confPath = userProvidedConfPath;
+        const isu = upsertFilePath("conf", confPath);
+        if (isu) {
+            console.log("Config path", confPath, "updated");
+        }
+    }
+    else {
+        // try to find a conf path in db
+        const cf = readFilePath("conf");
+        if (cf.found) {
+            confPath = cf.path;
+        }
+        else {
+            // use default conf path
+            confPath = path.join(confDir, "config.yml");
+            upsertFilePath("conf", confPath);
+        }
+    }
+    createConfigFileIfNotExists(confPath);
+    const { paths, pf, dd } = await processConfPath(confPath);
+    console.log("Using", confPath, "to update features");
+    if (pf.length > 0) {
+        updatePromptfilePath(pf);
+        promptfilePath.value = pf;
+    }
+    if (dd.length > 0) {
+        updateDataDirPath(dd);
+        dataDirPath.value = dd;
+    }
+    updateAllFeatures(paths);
+}
+export { updateConfCmd, updateFeaturesCmd, recreateDbFromConf, };

package/dist/utils/io.d.ts

@@ -0,0 +1,10 @@
+import type { InferenceResult, AgentSpec } from "@agent-smith/types";
+declare function readPromptFile(): string;
+declare function processOutput(res: InferenceResult): Promise<void>;
+declare function openAgentSpec(name: string): {
+    agentSpec: AgentSpec;
+    agentPath: string;
+};
+declare function getInputFromOptions(options: Record<string, any>): Promise<string | null>;
+declare function getAgentPrompt(name: string, args: Array<any> | Record<string, any>, options: Record<string, any>): Promise<string>;
+export { getAgentPrompt, getInputFromOptions, openAgentSpec, readPromptFile, processOutput, };

package/dist/utils/io.js

@@ -0,0 +1,98 @@
+import YAML from 'yaml';
+import { readClipboard } from '../utils/sys/clipboard.js';
+import { readAgent } from "../utils/sys/read_agent.js";
+import { getFeatureSpec } from "../state/features.js";
+import { runtimeWarning } from '../utils/user_msgs.js';
+import { initFilepaths, promptfilePath, outputMode, formatMode } from "../state/state.js";
+import { readFile } from "../utils/sys/read.js";
+import { runtimeError } from '../utils/user_msgs.js';
+import { writeToClipboard } from '../utils/sys/clipboard.js';
+import { marked } from 'marked';
+// @ts-ignore
+import { markedTerminal } from "marked-terminal";
+marked.use(markedTerminal());
+function readPromptFile() {
+    initFilepaths();
+    return readFile(promptfilePath.value);
+}
+async function processOutput(res) {
+    //if (!(outputMode.value == "clipboard")) { return }
+    let data = "";
+    //console.log("Process OUTPUT", typeof res);
+    let hasTextData = false;
+    if (typeof res == "object") {
+        if (res?.text) {
+            data = res.text;
+            hasTextData = true;
+        }
+        else {
+            try {
+                data = JSON.stringify(res);
+            }
+            catch (e) {
+                runtimeError("Unable to parse json result");
+            }
+        }
+    }
+    else {
+        data = res;
+    }
+    //onsole.log("OUTPUT", typeof res, data);
+    if (outputMode.value == "clipboard") {
+        //console.log("Writing to kb", data)
+        await writeToClipboard(data);
+    }
+    if (hasTextData) {
+        if (formatMode.value == "markdown") {
+            console.log("\n------------------\n");
+            console.log(marked.parse(data).trim());
+        }
+    }
+}
+function openAgentSpec(name) {
+    const { found, path } = getFeatureSpec(name, "agent");
+    if (!found) {
+        throw new Error(`agent ${name} not found`);
+    }
+    const res = readAgent(path);
+    if (!res.found) {
+        throw new Error(`agent ${name}, ${path} not found`);
+    }
+    const agentSpec = YAML.parse(res.ymlAgent);
+    agentSpec.name = name;
+    return { agentSpec: agentSpec, agentPath: path };
+}
+async function getInputFromOptions(options) {
+    let out = null;
+    if (options?.clipboardInput === true) {
+        out = await readClipboard();
+        options.clipboardInput = false;
+    }
+    else if (options?.inputFile === true) {
+        out = readPromptFile();
+        options.inputFile = false;
+    }
+    return out;
+}
+async function getAgentPrompt(name, args, options) {
+    const ic = await getInputFromOptions(options);
+    if (ic) {
+        return ic;
+    }
+    let pr = "";
+    if (Array.isArray(args)) {
+        if (args[0] !== undefined) {
+            pr = args[0];
+        }
+    }
+    else {
+        if (args?.prompt) {
+            pr = args.prompt;
+        }
+    }
+    if (pr.length == 0) {
+        runtimeWarning("empty prompt provided to agent", name);
+    }
+    return pr;
+}
+export { getAgentPrompt, getInputFromOptions, openAgentSpec, readPromptFile, processOutput, };

package/dist/utils/perf.d.ts

@@ -0,0 +1,9 @@
+declare const usePerfTimer: (startTimer?: boolean) => {
+    start: () => void;
+    time: () => string;
+    timeRaw: () => string | number;
+    printTime: () => void;
+    measure: (name: string) => void;
+    final: (name?: string) => void;
+};
+export { usePerfTimer };

package/dist/utils/perf.js

@@ -0,0 +1,63 @@
+const usePerfTimer = (startTimer = true) => {
+    let startTime;
+    const measurements = [];
+    let lastTime;
+    if (startTimer) {
+        startTime = performance.now();
+        lastTime = startTime;
+    }
+    const measure = (name) => {
+        const currentTime = performance.now();
+        const elapsedNs = Number(currentTime - lastTime);
+        const elapsedSec = elapsedNs / 1000;
+        measurements.push({ name, time: elapsedSec, percentage: 0 });
+        lastTime = currentTime;
+        console.log(name, elapsedSec);
+    };
+    const final = (name = "") => {
+        const totalTime = Number(performance.now() - startTime) / 1000;
+        console.log("\n*** Performance", name.length > 0 ? `for ${name}` : "", " ***");
+        measurements.forEach(m => {
+            m.percentage = (m.time / totalTime) * 100;
+            console.log(` - ${m.name}: ${m.time.toFixed(6)}s (${m.percentage.toFixed(2)}%)`);
+        });
+        console.log(`Total time: ${totalTime.toFixed(6)}s\n`);
+    };
+    const start = () => {
+        startTime = performance.now();
+        lastTime = startTime;
+    };
+    const _end = (raw) => {
+        if (!startTime) {
+            throw new Error("the timer has not started, can not end it");
+        }
+        const endTime = performance.now();
+        const duration = endTime - startTime;
+        if (raw) {
+            return duration;
+        }
+        const humanizedTime = _formatDuration(duration);
+        return humanizedTime;
+    };
+    const time = () => _end(false).toString();
+    const printTime = () => console.log(_end(false));
+    const timeRaw = () => _end(true);
+    const _formatDuration = (ms) => {
+        const seconds = ms / 1000;
+        const minutes = seconds / 60;
+        if (ms < 1000)
+            return `${ms.toFixed(2)} milliseconds`;
+        if (seconds < 60)
+            return `${seconds.toFixed(1)} seconds`;
+        return `${minutes.toFixed()} minutes ${(seconds % 60).toFixed()} seconds`;
+    };
+    return {
+        start,
+        time,
+        timeRaw,
+        printTime,
+        measure,
+        final,
+    };
+};
+export { usePerfTimer };

package/dist/utils/sys/clipboard.d.ts

@@ -0,0 +1,3 @@
+declare function readClipboard(): Promise<string>;
+declare function writeToClipboard(data: string): Promise<void>;
+export { readClipboard, writeToClipboard, };

package/dist/utils/sys/clipboard.js

@@ -0,0 +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/utils/sys/delete_file.d.ts

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

package/dist/utils/sys/delete_file.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/utils/sys/dirs.d.ts

@@ -0,0 +1,2 @@
+declare function createDirectoryIfNotExists(dirPath: string, recursive?: boolean): void;
+export { createDirectoryIfNotExists };

package/dist/utils/sys/dirs.js

@@ -0,0 +1,9 @@
+import * as fs from 'fs';
+import * as path from 'path';
+function createDirectoryIfNotExists(dirPath, recursive = false) {
+    const resolvedDirPath = path.resolve(dirPath);
+    if (!fs.existsSync(resolvedDirPath)) {
+        fs.mkdirSync(resolvedDirPath, { recursive: recursive });
+    }
+}
+export { createDirectoryIfNotExists };

package/dist/utils/sys/execute.d.ts

@@ -0,0 +1,13 @@
+declare function execute(command: string, args?: Array<string>, { onStdout, onStderr, onError, stream, }?: {
+    onStderr?: (data: any) => void;
+    onError?: (err: any) => void;
+    onStdout?: ((data: any) => void) | undefined;
+    stream?: boolean | undefined;
+}): Promise<string>;
+declare function runShellCmd(command: string, args?: Array<string>, { onStdout, onStderr, onError, onFinished, }?: {
+    onStdout?: (data: any) => void;
+    onStderr?: (data: any) => void;
+    onError?: (err: any) => void;
+    onFinished?: () => void;
+}): () => boolean;
+export { execute, runShellCmd };

package/dist/utils/sys/execute.js

@@ -0,0 +1,48 @@
+import { spawn } from "child_process";
+import { platform } from "os";
+async function execute(command, args = [], { onStdout = (data) => { }, onStderr = (data) => { }, onError = (data) => { }, stream = false, } = {
+    onStderr: (data) => console.log("stderr:", data),
+    onError: (err) => { if (err)
+        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');
+    child.stdout.on('data', (data) => {
+        buffer.push(data);
+        onStdout(data);
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (data) => onStderr(data));
+    child.on("error", (data) => onError(data));
+    let finish;
+    let end = new Promise((r) => finish = r);
+    child.on('close', () => finish(true));
+    await end;
+    if (!stream) {
+        return buffer.join("\n");
+    }
+    else {
+        return buffer.join("");
+    }
+}
+function runShellCmd(command, args = [], { onStdout = (data) => { }, onStderr = (data) => { }, onError = (data) => { }, onFinished = () => { }, } = {
+    onStdout: (data) => console.log("stdout:", data),
+    onStderr: (data) => console.log("stderr:", data),
+    onError: (err) => { if (err)
+        throw err; },
+    onFinished: () => { },
+}) {
+    const useShell = platform() === 'win32';
+    var child = spawn(command, args, { shell: useShell });
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (data) => onStdout(data));
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (data) => onStderr(data));
+    child.on("error", (data) => onError(data));
+    child.on('close', () => onFinished());
+    return () => child.kill();
+}
+export { execute, runShellCmd };

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

@@ -0,0 +1,3 @@
+declare function readFile(fp: string): string;
+declare function checkIfFileExists(filePath: string): Promise<boolean>;
+export { readFile, checkIfFileExists, };

package/dist/utils/sys/read.js

@@ -0,0 +1,21 @@
+import { default as fs } from "fs";
+import { access, constants } from 'fs/promises';
+import { resolve } from 'path';
+function readFile(fp) {
+    try {
+        return fs.readFileSync(fp, 'utf8');
+    }
+    catch (e) {
+        throw new Error(`reading file ${e}}`);
+    }
+}
+async function checkIfFileExists(filePath) {
+    try {
+        await access(resolve(filePath), constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { readFile, checkIfFileExists, };

package/dist/utils/sys/read_agent.d.ts

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

package/dist/utils/sys/read_agent.js

@@ -0,0 +1,23 @@
+import { default as fs } from "fs";
+import { default as path } from "path";
+function readAgent(taskpath) {
+    if (!fs.existsSync(taskpath)) {
+        return { ymlAgent: "", found: false };
+    }
+    const data = fs.readFileSync(taskpath, 'utf8');
+    return { ymlAgent: data, found: true };
+}
+function readAgentsDir(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 { readAgent, readAgentsDir, };

package/dist/utils/sys/read_cmds.d.ts

@@ -0,0 +1,7 @@
+import type { UserCmdDef } from "@agent-smith/types";
+declare function readCmd(name: string, cmdPath: string): Promise<UserCmdDef | null>;
+declare function readUserCmd(name: string, cmdPath: string): Promise<{
+    found: boolean;
+    userCmd: UserCmdDef;
+}>;
+export { readCmd, readUserCmd, };

package/dist/utils/sys/read_cmds.js

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

package/dist/utils/sys/read_conf.d.ts

@@ -0,0 +1,6 @@
+import { ConfigFile } from "@agent-smith/types";
+declare function readConf(confPath: string): {
+    found: boolean;
+    data: ConfigFile;
+};
+export { readConf };

package/dist/utils/sys/read_conf.js

@@ -0,0 +1,12 @@
+import { default as fs } from "fs";
+import YAML from 'yaml';
+function readConf(confPath) {
+    if (!fs.existsSync(confPath)) {
+        return { data: {}, found: false };
+    }
+    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/utils/sys/read_features.d.ts

@@ -0,0 +1,3 @@
+import { Features } from "@agent-smith/types";
+declare function readFeaturesDir(dir: string): Features;
+export { readFeaturesDir };