@agent-smith/cli 0.0.1

package/dist/cmd/sys/execute.js

@@ -0,0 +1,44 @@
+import { spawn } from "child_process";
+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();
+    const child = spawn(command, args, { shell: false });
+    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 run(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: () => { },
+}) {
+    var child = spawn(command, args);
+    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, run };

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

@@ -0,0 +1,3 @@
+import { Cmd } from "../../interfaces.js";
+declare function readCmds(dir: string): Promise<Record<string, Cmd>>;
+export { readCmds };

package/dist/cmd/sys/read_cmds.js

@@ -0,0 +1,26 @@
+import { default as fs } from "fs";
+import { default as path } from "path";
+function _readCmdsDir(dir) {
+    const fileNames = new Array;
+    fs.readdirSync(dir).forEach((filename) => {
+        const filepath = path.join(dir, filename);
+        const isDir = fs.statSync(filepath).isDirectory();
+        if (!isDir) {
+            if (filename.endsWith(".ts") || filename.endsWith(".js")) {
+                const name = filename.replace(".js", "").replace(".ts", "");
+                fileNames.push(name);
+            }
+        }
+    });
+    return fileNames;
+}
+async function readCmds(dir) {
+    const cmds = {};
+    const fileNames = _readCmdsDir(dir);
+    for (const name of fileNames) {
+        const { cmd } = await import(path.join(dir, name + ".js"));
+        cmds[name] = cmd;
+    }
+    return cmds;
+}
+export { readCmds };

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

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

package/dist/cmd/sys/read_conf.js

@@ -0,0 +1,11 @@
+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);
+    return { data: data, found: true };
+}
+export { readConf };

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

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

package/dist/cmd/sys/read_features.js

@@ -0,0 +1,83 @@
+import { default as fs } from "fs";
+import { default as path } from "path";
+function _readDir(dir, ext) {
+    const fileNames = new Array;
+    fs.readdirSync(dir).forEach((filename) => {
+        const filepath = path.join(dir, filename);
+        const isDir = fs.statSync(filepath).isDirectory();
+        if (!isDir) {
+            for (let extension of ext) {
+                if (filename.endsWith(extension)) {
+                    fileNames.push(filename);
+                }
+            }
+        }
+    });
+    return fileNames;
+}
+function readFeaturesDir(dir) {
+    const feats = {
+        task: [],
+        job: [],
+        action: [],
+        cmd: [],
+    };
+    let dirpath = path.join(dir, "tasks");
+    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.task.push({
+                name: name,
+                path: path.join(dirpath),
+                ext: ext,
+            });
+        });
+    }
+    dirpath = path.join(dir, "jobs");
+    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({
+                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, "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,
+            });
+        });
+    }
+    return feats;
+}
+export { readFeaturesDir };

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

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

package/dist/cmd/sys/read_yml_action.js

@@ -0,0 +1,11 @@
+import { default as fs } from "fs";
+import YAML from 'yaml';
+function readYmlAction(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 { readYmlAction };

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

@@ -0,0 +1,3 @@
+import { PythonShell } from 'python-shell';
+declare function runPyScript(rsShell: PythonShell, pythonPath: string, scriptPath: string, scriptArgs: Array<string>, handleOutputFrom?: "msg" | "stderr", onEmitLine?: CallableFunction): Promise<string[]>;
+export { runPyScript };

package/dist/cmd/sys/run_python.js

@@ -0,0 +1,43 @@
+import { PythonShell } from 'python-shell';
+async function runPyScript(rsShell, pythonPath, scriptPath, scriptArgs, handleOutputFrom = "msg", 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 msgs = new Array();
+    function handleLine(msg) {
+        if (onEmitLine) {
+            onEmitLine(msg);
+        }
+        msgs.push(msg);
+    }
+    rsShell.on('message', function (message) {
+        if (handleOutputFrom == "msg") {
+            handleLine(message);
+        }
+    });
+    rsShell.on('stderr', function (err) {
+        console.log("STDERR", err);
+        if (handleOutputFrom == "stderr") {
+            handleLine(err);
+        }
+        else {
+            promiseResolve(true);
+        }
+    });
+    rsShell.on('pythonError', function (err) {
+        console.log("PYERR", `${err.message}, ${err.traceback}`);
+        promiseResolve(true);
+    });
+    rsShell.end(function (err, code, signal) {
+        promiseResolve(true);
+    });
+    await promise;
+    return msgs;
+}
+export { runPyScript };

package/dist/conf.d.ts

@@ -0,0 +1,4 @@
+declare const confDir: string;
+declare const dbPath: string;
+declare function createConfDirIfNotExists(): boolean;
+export { confDir, dbPath, createConfDirIfNotExists, };

package/dist/conf.js

@@ -0,0 +1,12 @@
+import path from "path";
+import { default as fs } from "fs";
+const confDir = path.join(process.env.HOME, ".config/agent-smith/cli");
+const dbPath = path.join(confDir, "config.db");
+function createConfDirIfNotExists() {
+    if (!fs.existsSync(confDir)) {
+        fs.mkdirSync(confDir, { recursive: true });
+        return false;
+    }
+    return true;
+}
+export { confDir, dbPath, createConfDirIfNotExists, };

package/dist/db/db.d.ts

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

package/dist/db/db.js

@@ -0,0 +1,16 @@
+import DatabaseConstructor from "better-sqlite3";
+import { schemas } from "./schemas.js";
+import { createConfDirIfNotExists, dbPath } from "../conf.js";
+createConfDirIfNotExists();
+let db = new DatabaseConstructor(dbPath);
+function initDb(isVerbose = false) {
+    schemas.forEach((s) => {
+        db.exec(s);
+        if (isVerbose) {
+            console.log(`Schema executed: ${s}`);
+        }
+    });
+}
+function dbPopulateDefaults() {
+}
+export { db, initDb, dbPopulateDefaults, };

package/dist/db/read.d.ts

@@ -0,0 +1,9 @@
+import { FeatureSpec, FeatureType } from "../interfaces.js";
+declare function readFeaturePaths(): Array<string>;
+declare function readPlugins(): Array<Record<string, string>>;
+declare function readFeatures(): Record<FeatureType, Record<string, string>>;
+declare function readFeature(name: string, type: FeatureType): {
+    found: boolean;
+    feature: FeatureSpec;
+};
+export { readFeatures, readFeaturePaths, readFeature, readPlugins };

package/dist/db/read.js

@@ -0,0 +1,53 @@
+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 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) {
+    const stmt = db.prepare(`SELECT name, path FROM ${type}`);
+    const data = stmt.all();
+    let f = {};
+    data.forEach((row) => {
+        f[row.name] = row.path;
+    });
+    return f;
+}
+function readFeatures() {
+    const feats = { task: {}, job: {}, action: {}, cmd: {} };
+    feats.task = readFeaturesType("task");
+    feats.job = readFeaturesType("job");
+    feats.action = readFeaturesType("action");
+    feats.cmd = readFeaturesType("cmd");
+    return feats;
+}
+function readFeature(name, type) {
+    const q = `SELECT id, path, ext FROM ${type} WHERE name='${name}'`;
+    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,
+            }
+        };
+    }
+    return { found: false, feature: {} };
+}
+export { readFeatures, readFeaturePaths, readFeature, readPlugins };

package/dist/db/schemas.d.ts

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

package/dist/db/schemas.js

@@ -0,0 +1,42 @@
+const filepaths = `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 (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL
+);`;
+const plugins = `CREATE TABLE IF NOT EXISTS plugin (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL
+);`;
+const tasks = `CREATE TABLE IF NOT EXISTS task (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml') )
+);`;
+const jobs = `CREATE TABLE IF NOT EXISTS job (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    path TEXT NOT NULL,
+    ext TEXT NOT NULL CHECK ( ext IN ('yml') )
+);`;
+const actions = `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', 'js', 'py') )
+);`;
+const cmds = `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 schemas = [
+    filepaths, featurespaths, tasks, jobs, actions, cmds, plugins
+];
+export { schemas };

package/dist/db/write.d.ts

@@ -0,0 +1,6 @@
+import { Features } from "../interfaces.js";
+declare function insertDefaultFilepaths(): void;
+declare function insertFeaturesPathIfNotExists(path: string): boolean;
+declare function insertPluginIfNotExists(n: string, p: string): boolean;
+declare function updateFeatures(feats: Features): void;
+export { insertDefaultFilepaths, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, };

package/dist/db/write.js

@@ -0,0 +1,56 @@
+import { db } from "./db.js";
+const defaultFilepaths = {
+    prompt: "",
+    override: "",
+};
+function insertDefaultFilepaths() {
+    for (const [k, v] of Object.entries(defaultFilepaths)) {
+        const stmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
+        stmt.run(k, v);
+    }
+}
+function insertFeaturesPathIfNotExists(path) {
+    const stmt1 = db.prepare("SELECT * FROM featurespath WHERE path = ?");
+    const result = stmt1.get(path);
+    if (result?.id) {
+        return true;
+    }
+    const stmt = db.prepare("INSERT INTO featurespath (path) VALUES (?)");
+    stmt.run(path);
+    return false;
+}
+function insertPluginIfNotExists(n, p) {
+    const stmt1 = db.prepare("SELECT * FROM plugin WHERE name = ?");
+    const result = stmt1.get(n);
+    if (result?.id) {
+        return true;
+    }
+    const stmt = db.prepare("INSERT INTO plugin (name, path) VALUES (?,?)");
+    stmt.run(n, p);
+    return false;
+}
+function upsertAndCleanFeatures(feats, type) {
+    const stmt = db.prepare(`SELECT name FROM ${type}`);
+    const rows = stmt.all();
+    const names = rows.map(row => row.name);
+    feats.forEach((feat) => {
+        if (!names.includes(feat.name)) {
+            const insertStmt = db.prepare(`INSERT INTO ${type} (name, path, ext) VALUES (?, ?, ?)`);
+            insertStmt.run(feat.name, feat.path, feat.ext);
+        }
+    });
+    const availableFeatsNames = feats.map((f) => f.name);
+    names.forEach((name) => {
+        if (!availableFeatsNames.includes(name)) {
+            const deleteStmt = db.prepare(`DELETE FROM ${type} WHERE name = ?`);
+            deleteStmt.run(name);
+        }
+    });
+}
+function updateFeatures(feats) {
+    upsertAndCleanFeatures(feats.task, "task");
+    upsertAndCleanFeatures(feats.job, "job");
+    upsertAndCleanFeatures(feats.action, "action");
+    upsertAndCleanFeatures(feats.cmd, "cmd");
+}
+export { insertDefaultFilepaths, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { argv } from 'process';
+import { query } from "./cli.js";
+import { initState, runMode } from './state/state.js';
+import { initAgent } from './agent.js';
+import { initCmds, parseCmd } from './cmd/cmds.js';
+async function main() {
+    if (argv.length == 2) {
+        runMode.value = "cli";
+    }
+    await initState();
+    await initCmds();
+    await initAgent(runMode.value);
+    switch (runMode.value) {
+        case "cli":
+            await query();
+            break;
+        default:
+            await parseCmd();
+            break;
+    }
+}
+(async () => {
+    await main();
+})();

package/dist/interfaces.d.ts

@@ -0,0 +1,49 @@
+interface Cmd {
+    cmd: CmdExecutor;
+    description: string;
+    args?: string;
+}
+interface FeatureSpec {
+    name: string;
+    path: string;
+    ext: FeatureExtension;
+}
+interface Features {
+    task: Array<{
+        name: string;
+        path: string;
+        ext: TaskExtension;
+    }>;
+    job: Array<{
+        name: string;
+        path: string;
+        ext: JobExtension;
+    }>;
+    cmd: Array<{
+        name: string;
+        path: string;
+        ext: CmdExtension;
+    }>;
+    action: Array<{
+        name: string;
+        path: string;
+        ext: ActionExtension;
+    }>;
+}
+interface ConfigFile {
+    promptfile: string;
+    features: Array<string>;
+    plugins: Array<string>;
+}
+type CmdExecutor = (args: Array<string>, options: any) => Promise<any>;
+type InputMode = "manual" | "promptfile" | "clipboard";
+type OutputMode = "txt" | "clipboard";
+type RunMode = "cli" | "cmd";
+type FormatMode = "text" | "markdown";
+type FeatureType = "task" | "job" | "action" | "cmd";
+type ActionExtension = "js" | "py" | "yml";
+type TaskExtension = "yml";
+type JobExtension = "yml";
+type CmdExtension = "js";
+type FeatureExtension = TaskExtension | JobExtension | CmdExtension | ActionExtension;
+export { Cmd, CmdExecutor, InputMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, JobExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, };

package/dist/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+import { execute, run } from "./cmd/sys/execute.js";
+import { executeJobCmd } from "./cmd/lib/execute_job.js";
+import { writeToClipboard } from "./cmd/sys/clipboard.js";
+import { pingCmd } from "./cmd/cmds.js";
+export { execute, run, pingCmd, executeJobCmd, writeToClipboard, };

package/dist/main.js

@@ -0,0 +1,5 @@
+import { execute, run } from "./cmd/sys/execute.js";
+import { executeJobCmd } from "./cmd/lib/execute_job.js";
+import { writeToClipboard } from "./cmd/sys/clipboard.js";
+import { pingCmd } from "./cmd/cmds.js";
+export { execute, run, pingCmd, executeJobCmd, writeToClipboard, };

package/dist/state/features.d.ts

@@ -0,0 +1,8 @@
+import { FeatureExtension, FeatureType, Features } from "../interfaces.js";
+declare function readFeaturesDirs(featuresPaths: Array<string>): Features;
+declare function getFeatureSpec(name: string, type: FeatureType): {
+    found: boolean;
+    path: string;
+    ext: FeatureExtension;
+};
+export { readFeaturesDirs, getFeatureSpec, };

package/dist/state/features.js

@@ -0,0 +1,29 @@
+import { default as path } from "path";
+import { readFeaturesDir } from "../cmd/sys/read_features.js";
+import { readFeature } from "../db/read.js";
+function readFeaturesDirs(featuresPaths) {
+    const feats = {
+        task: [],
+        job: [],
+        action: [],
+        cmd: [],
+    };
+    featuresPaths.forEach((dir) => {
+        console.log("Reading feats in", dir);
+        const _f = readFeaturesDir(dir);
+        _f.task.forEach((item) => feats.task.push(item));
+        _f.job.forEach((item) => feats.job.push(item));
+        _f.action.forEach((item) => feats.action.push(item));
+        _f.cmd.forEach((item) => feats.cmd.push(item));
+    });
+    return feats;
+}
+function getFeatureSpec(name, type) {
+    const { found, feature } = readFeature(name, type);
+    if (!found) {
+        return { found: false, path: "", ext: "yml" };
+    }
+    const f = path.join(feature.path, name + "." + feature.ext);
+    return { found: true, path: f, ext: feature.ext };
+}
+export { readFeaturesDirs, getFeatureSpec, };

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,24 @@
+import { execute } from "../main.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();
+    names.forEach((p) => {
+        plugins.push({
+            name: p,
+            path: path.join(rootPath, p, "dist")
+        });
+    });
+    return plugins;
+}
+async function readPluginsPaths() {
+    const paths = new Array();
+    const plugins = readPlugins();
+    plugins.forEach((p) => {
+        paths.push(p.path);
+    });
+    return paths;
+}
+export { buildPluginsPaths, readPluginsPaths };

package/dist/state/state.d.ts

@@ -0,0 +1,15 @@
+import { PythonShell } from 'python-shell';
+import { InputMode, RunMode, FormatMode, OutputMode } from "../interfaces.js";
+declare let pyShell: PythonShell;
+declare const inputMode: import("@vue/reactivity").Ref<InputMode, InputMode>;
+declare const outputMode: import("@vue/reactivity").Ref<OutputMode, OutputMode>;
+declare const runMode: import("@vue/reactivity").Ref<RunMode, RunMode>;
+declare const formatMode: import("@vue/reactivity").Ref<FormatMode, FormatMode>;
+declare const promptfile: import("@vue/reactivity").Ref<string, string>;
+declare const lastCmd: {
+    name: string;
+    args: Array<string>;
+};
+declare function initFeatures(): Promise<void>;
+declare function initState(): Promise<void>;
+export { inputMode, outputMode, runMode, formatMode, lastCmd, promptfile, initState, initFeatures, pyShell, };