@agent-smith/core 0.0.1

package/dist/utils/sys/read_features.js

@@ -0,0 +1,134 @@
+import { default as fs } from "fs";
+import { default as path } from "path";
+import { default as fm } from "front-matter";
+import { readFile } from "./read.js";
+import { runtimeDataError } from "../user_msgs.js";
+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))) {
+                fileNames.push(filename);
+            }
+        }
+    });
+    return fileNames;
+}
+function _readSkills(dir) {
+    const dirs = new Array();
+    fs.readdirSync(dir).forEach((p) => {
+        const isDir = fs.statSync(path.join(dir, p)).isDirectory();
+        const skp = path.join(dir, p, "SKILL.md");
+        const fc = readFile(skp);
+        const data = fm(fc);
+        //console.log("FM DATA", data);
+        if (!data.attributes?.name) {
+            runtimeDataError(`error in skill ${p}: missing name`);
+        }
+        if (!data.attributes?.description) {
+            runtimeDataError(`error in skill ${p}: missing description`);
+        }
+        //console.log("SKP", skp);
+        if (isDir) {
+            dirs.push({ name: p, path: skp, info: { name: data.attributes.name, description: data.attributes.description } });
+        }
+    });
+    return dirs;
+}
+function readFeaturesDir(dir) {
+    const feats = {
+        action: [],
+        cmd: [],
+        workflow: [],
+        adaptater: [],
+        agent: [],
+        skill: [],
+    };
+    let dirpath = path.join(dir, "agents");
+    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.agent.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
+    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.workflow.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
+    dirpath = path.join(dir, "actions");
+    if (fs.existsSync(dirpath)) {
+        const data = _readDir(dirpath, [".yml", ".js", ".py"]);
+        data.forEach((filename) => {
+            const parts = filename.split(".");
+            const ext = parts.pop();
+            const name = parts.join("");
+            feats.action.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
+    dirpath = path.join(dir, "adaptaters");
+    if (fs.existsSync(dirpath)) {
+        const data = _readDir(dirpath, [".js"]);
+        data.forEach((filename) => {
+            const parts = filename.split(".");
+            const ext = parts.pop();
+            const name = parts.join("");
+            feats.adaptater.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
+    dirpath = path.join(dir, "cmds");
+    if (fs.existsSync(dirpath)) {
+        const data = _readDir(dirpath, [".js"]);
+        data.forEach((filename) => {
+            const parts = filename.split(".");
+            const ext = parts.pop();
+            const name = parts.join("");
+            feats.cmd.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
+    dirpath = path.join(dir, "skills");
+    if (fs.existsSync(dirpath)) {
+        const data = _readSkills(dirpath);
+        data.forEach((s) => {
+            feats.skill.push({
+                name: s.name,
+                path: s.path,
+                ext: "md",
+                variables: s.info,
+            });
+        });
+    }
+    return feats;
+}
+export { readFeaturesDir };

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

@@ -0,0 +1,5 @@
+declare function readYmlFile(path: string): {
+    found: boolean;
+    data: Record<string, any>;
+};
+export { readYmlFile };

package/dist/utils/sys/read_yml_file.js

@@ -0,0 +1,11 @@
+import { default as fs } from "fs";
+import YAML from 'yaml';
+function readYmlFile(path) {
+    if (!fs.existsSync(path)) {
+        return { data: {}, found: false };
+    }
+    const file = fs.readFileSync(path, 'utf8');
+    const data = YAML.parse(file);
+    return { data: data, found: true };
+}
+export { readYmlFile };

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

@@ -0,0 +1,6 @@
+import { PythonShell } from 'python-shell';
+declare function runPyScript(rsShell: PythonShell, pythonPath: string, scriptPath: string, scriptArgs: Array<string>, onEmitLine?: CallableFunction): Promise<{
+    data: any;
+    error?: Error;
+}>;
+export { runPyScript };

package/dist/utils/sys/run_python.js

@@ -0,0 +1,39 @@
+import { PythonShell } from 'python-shell';
+async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, onEmitLine) {
+    const _options = {
+        mode: "text",
+        pythonPath: pythonPath,
+        pythonOptions: ['-u'],
+        args: scriptArgs,
+    };
+    let promiseResolve;
+    let promise = new Promise((resolve) => promiseResolve = resolve);
+    rsShell = new PythonShell(scriptPath, _options);
+    const res = { data: new Array() };
+    function handleLine(msg) {
+        if (onEmitLine) {
+            onEmitLine(msg);
+        }
+        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;
+    return res;
+}
+export { runPyScript };

package/dist/utils/text.d.ts

@@ -0,0 +1,2 @@
+declare function extractBetweenTags(text: string, startTag: string, endTag: string): string;
+export { extractBetweenTags, };

package/dist/utils/text.js

@@ -0,0 +1,28 @@
+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) {
+            contentEnd = text.indexOf(endTag, contentStart);
+            if (contentEnd === -1)
+                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) {
+        throw new Error(`Error parsing content between tags ${startTag} ${endTag}: ${error}`);
+    }
+}
+export { extractBetweenTags, };

package/dist/utils/user_msgs.d.ts

@@ -0,0 +1,5 @@
+declare function runtimeError(...msg: string[]): void;
+declare function runtimeWarning(...msg: string[]): void;
+declare function runtimeDataError(...msg: string[]): void;
+declare function runtimeInfo(...msg: string[]): void;
+export { runtimeError, runtimeWarning, runtimeDataError, runtimeInfo, };

package/dist/utils/user_msgs.js

@@ -0,0 +1,19 @@
+import { exit } from "process";
+import colors from "ansi-colors";
+function runtimeError(...msg) {
+    console.warn("💥", colors.dim("Runtime error:"), ...msg);
+    exit(1);
+}
+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, };

package/dist/workflows/cmd.d.ts

@@ -0,0 +1,3 @@
+import type { AgentInferenceOptions } from "@agent-smith/types";
+declare function executeWorkflow(wname: string, args: any, options: AgentInferenceOptions & Record<string, any>): Promise<any>;
+export { executeWorkflow, };

package/dist/workflows/cmd.js

@@ -0,0 +1,189 @@
+import { pathToFileURL } from "node:url";
+import { getFeatureSpec } from "../state/features.js";
+import { executeAction } from "../actions/cmd.js";
+import { executeAdaptater } from "../adaptaters/cmd.js";
+import { executeAgent } from "../agents/cmd.js";
+import { getInputFromOptions, getAgentPrompt } from "../utils/io.js";
+import { runtimeError } from "../utils/user_msgs.js";
+import { readWorkflow } from "./read.js";
+async function executeWorkflow(wname, args, options) {
+    const { workflow, found } = await readWorkflow(wname);
+    if (!found) {
+        throw new Error(`Workflow ${wname} not found`);
+    }
+    const isDebug = options?.debug === true;
+    const isVerbose = options?.verbose === true;
+    const stepNames = Object.keys(workflow);
+    if (isDebug || isVerbose) {
+        console.log("Running workflow", wname, stepNames.length, "steps");
+    }
+    let i = 0;
+    const finalTaskIndex = stepNames.length - 1;
+    let taskRes = { cmdArgs: args };
+    //console.log("WPARAMS", taskRes);
+    let prevStepType = null;
+    //console.log("WF OPTS", options);
+    for (const step of workflow) {
+        if (isDebug || isVerbose) {
+            console.log(i + 1, step.name, `\x1b[2m${step.type}\x1b[0m`);
+        }
+        switch (step.type) {
+            case "agent":
+                try {
+                    let tdata = { prompt: "", ...taskRes };
+                    if (i == 0) {
+                        tdata.prompt = await getAgentPrompt(step.name, taskRes.cmdArgs, options);
+                    }
+                    else {
+                        if (prevStepType) {
+                            if (prevStepType == "action") {
+                                if (taskRes?.args) {
+                                    if (typeof taskRes.args == "string") {
+                                        tdata.prompt = taskRes.args;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (!tdata?.prompt) {
+                        throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
+                    }
+                    options.isAgent = true;
+                    //console.log("WF EXEC AGENT", step.name, tdata, options);
+                    const tr = await executeAgent(step.name, tdata, options);
+                    options.isAgent = false;
+                    taskRes = { ...tr, ...taskRes };
+                }
+                catch (e) {
+                    throw new Error(`workflow task ${i + 1}: ${e}`);
+                }
+                break;
+            case "action":
+                try {
+                    //console.log("EXEC ACTION ARGS", taskRes);
+                    //const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
+                    let actArgs;
+                    if (i == 0) {
+                        actArgs = taskRes.cmdArgs;
+                        const inputData = await getInputFromOptions(options);
+                        if (inputData) {
+                            actArgs.push(inputData);
+                        }
+                    }
+                    else {
+                        actArgs = taskRes;
+                    }
+                    const ares = await executeAction(step.name, actArgs, options, true);
+                    //console.log("WF ACTION RES", typeof ares, ares);
+                    //console.log("LAST ACT", i, finalTaskIndex);
+                    if (i == finalTaskIndex && !options?.isToolCall) {
+                        console.log(ares);
+                        break;
+                    }
+                    if (typeof ares == "string" || Array.isArray(ares)) {
+                        taskRes.args = ares;
+                        //console.log("ARRAY ACTION RES", taskRes)
+                    }
+                    else {
+                        taskRes = { ...ares, ...taskRes };
+                    }
+                }
+                catch (e) {
+                    throw new Error(`workflow action ${i + 1}: ${e}`);
+                }
+                //console.log("END ACTION", step.name)
+                break;
+            case "adaptater":
+                try {
+                    //console.log("WF AD ARGS IN", taskRes);
+                    //console.log("AD OPTS IN", options);
+                    let actArgs;
+                    if (i == 0) {
+                        //console.log("TR", taskRes);
+                        actArgs = taskRes.cmdArgs;
+                        //console.log("ACT ARGS", actArgs);
+                        const inputData = await getInputFromOptions(options);
+                        if (inputData) {
+                            actArgs.push(inputData);
+                        }
+                    }
+                    else {
+                        actArgs = taskRes;
+                    }
+                    const adres = await executeAdaptater(step.name, actArgs, options);
+                    //console.log("WF AD FINAL RES", taskRes);
+                    //console.log("LAST ACT", i, finalTaskIndex);
+                    if (i == finalTaskIndex && !options?.isToolCall) {
+                        console.log(adres);
+                        break;
+                    }
+                    //console.log("WF AD RES", typeof adres, adres);
+                    if (typeof adres == "string" || Array.isArray(adres)) {
+                        taskRes.args = adres;
+                        //console.log("WF AD IT RES", taskRes);
+                    }
+                    else {
+                        taskRes = { ...adres };
+                    }
+                    //console.log("WF ADAPT RES", typeof ares, Array.isArray(ares) ? ares.length : "NA");
+                }
+                catch (e) {
+                    throw new Error(`workflow adaptater ${i + 1}: ${e}`);
+                }
+                break;
+            case "cmd":
+                try {
+                    const { found, path } = getFeatureSpec(step.name, "cmd");
+                    if (!found) {
+                        throw new Error(`Command ${step.name} not found`);
+                    }
+                    const url = pathToFileURL(path).href;
+                    let jsa;
+                    try {
+                        jsa = await import(/* @vite-ignore */ url);
+                    }
+                    catch (e) {
+                        throw new Error(`cmd import error ${e}`);
+                    }
+                    if (!jsa?.runCmd) {
+                        runtimeError(`workflow ${wname}: can not import the runCmd function from step ${i} for command ${step.name}: please add a runCmd function export`);
+                        return;
+                    }
+                    let cArgs;
+                    if (i == 0) {
+                        cArgs = taskRes.cmdArgs;
+                        const inputData = await getInputFromOptions(options);
+                        if (inputData) {
+                            cArgs.push(inputData);
+                        }
+                    }
+                    else {
+                        cArgs = taskRes;
+                    }
+                    const cres = await jsa.runCmd(cArgs, options);
+                    if (typeof cres == "string" || Array.isArray(cres)) {
+                        taskRes.args = cres;
+                    }
+                    else {
+                        taskRes = { ...cres, ...taskRes };
+                    }
+                }
+                catch (e) {
+                    throw new Error(`workflow command ${i + 1}: ${e}`);
+                }
+                break;
+            default:
+                throw new Error(`unknown workflow step type ${step.type} in workflow ${wname}`);
+        }
+        prevStepType = step.type;
+        //console.log("WF NODE RES", step.type, taskRes);
+        /*if (isDebug) {
+            console.log("->", params);
+        }*/
+        //console.log("WFR", taskRes)
+        ++i;
+    }
+    //console.log("WF RES")
+    return taskRes;
+}
+export { executeWorkflow, };

package/dist/workflows/read.d.ts

@@ -0,0 +1,6 @@
+import type { WorkflowStep } from '@agent-smith/types';
+declare function readWorkflow(name: string): Promise<{
+    found: boolean;
+    workflow: Array<WorkflowStep>;
+}>;
+export { readWorkflow };

package/dist/workflows/read.js

@@ -0,0 +1,61 @@
+import { default as fs } from "fs";
+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];
+        const name = sval;
+        const wf = {
+            name: name,
+            type: type == "command" ? "cmd" : type,
+        };
+        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: {} };
+    }
+    if (!fs.existsSync(path)) {
+        return { data: {}, found: false };
+    }
+    const file = fs.readFileSync(path, 'utf8');
+    const data = YAML.parse(file);
+    data.name = name;
+    return { data: data, found: true };
+}
+async function readWorkflow(name) {
+    const { found, ext } = getFeatureSpec(name, "workflow");
+    if (!found) {
+        return { found: false, workflow: [] };
+    }
+    let wf = new Array();
+    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: [] };
+                }
+                wf = workflow;
+            }
+            catch (e) {
+                throw new Error(`Workflow ${name} create error: ${e}`);
+            }
+            break;
+        default:
+            throw new Error(`Workflow ${name} extension ${ext} not implemented`);
+    }
+    return { found: true, workflow: wf };
+}
+export { readWorkflow };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@agent-smith/core",
+  "version": "0.0.1",
+  "description": "Agent Smith core",
+  "repository": "https://github.com/synw/agent-smith",
+  "scripts": {
+    "build": "rm -rf dist/* && tsc && cp -r src/features/agents dist/features && cp -r src/features/workflows dist/features && cp -r src/features/fragments dist/features && cp -r src/features/skills dist/features"
+  },
+  "dependencies": {
+    "@agent-smith/agent": "^0.5.0",
+    "@intrinsicai/gbnfgen": "^0.12.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@vue/reactivity": "^3.5.35",
+    "better-sqlite3": "^12.10.0",
+    "clipboardy": "^5.3.1",
+    "front-matter": "^4.0.2",
+    "node-notifier": "^10.0.1",
+    "python-shell": "^5.0.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@agent-smith/types": "^0.0.5",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.9.1",
+    "@types/node-notifier": "^8.0.5",
+    "tslib": "^2.8.1",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT"
+}