@agent-smith/cli 0.0.115 → 0.0.118

package/dist/cmd/lib/tasks/conf.js

@@ -1,131 +0,0 @@
-import { useTemplateForModel } from "@agent-smith/tfm";
-const tfm = useTemplateForModel();
-function guessTemplate(modelname) {
-    const gt = tfm.guess(modelname);
-    if (gt == "none") {
-        throw new Error(`Unable to guess the template for ${modelname}: please provide a template name: --tpl templatename`);
-    }
-    return gt;
-}
-function configureTaskModel(itConf, taskSpec) {
-    //console.log("IT CONF", itConf);
-    //console.log("TASK SPEC", taskSpec);
-    //let modelName: string = "";
-    //let templateName: string = "";
-    let ip = itConf.inferParams;
-    let isModelFromTaskFile = false;
-    let model = { template: "", name: "" };
-    let foundModel = false;
-    let foundTemplate = false;
-    if (itConf?.templateName) {
-        model.template = itConf.templateName;
-        foundTemplate = true;
-    }
-    if (!foundTemplate) {
-        if (itConf?.model?.name) {
-            const gt = guessTemplate(itConf.model.name);
-            model.template = gt;
-            foundTemplate = true;
-        }
-        else if (taskSpec?.model?.template) {
-            model.template = taskSpec.model.template;
-            foundTemplate = true;
-        }
-        else {
-            const gt = guessTemplate(taskSpec.model.name);
-            model.template = gt;
-            foundTemplate = true;
-        }
-    }
-    if (itConf?.model?.name) {
-        if (taskSpec?.models && Object.keys(taskSpec.models).includes(itConf.model.name)) {
-            // try to find the model from the task's models
-            for (const [k, v] of Object.entries(taskSpec.models)) {
-                //console.log("TSM", modelName, "/", k);
-                if (k == itConf.model.name) {
-                    model = v;
-                    if (v?.inferParams) {
-                        const tip = v.inferParams;
-                        for (const [k, v] of Object.entries(tip)) {
-                            // @ts-ignore
-                            ip[k] = v;
-                        }
-                    }
-                    if (v?.system) {
-                        model.system = v.system;
-                    }
-                    if (v.assistant) {
-                        model.assistant = v.assistant;
-                    }
-                    isModelFromTaskFile = true;
-                    foundModel = true;
-                    break;
-                }
-            }
-        }
-        else {
-            model.name = itConf.model.name;
-            foundModel = true;
-        }
-    }
-    else {
-        if (!taskSpec?.model) {
-            throw new Error(`No model found: either specify a model in the task or use the -m flag`);
-        }
-        model = taskSpec.model;
-        foundModel = true;
-    }
-    // try to find the models from db models
-    /*if (!found) {
-        const m = readModel(modelName);
-        //console.log("FM", m.found, m)
-        //console.log("DBM", templateName, "/", m.modelData.template);
-        if (m.found) {
-            model = m.modelData as ModelSpec;
-            model.template = templateName ?? m.modelData.template;
-            found = true
-        }
-    }*/
-    // fallback to use the model name directly
-    if (!foundModel) {
-        throw new Error(`No model found in task`);
-    }
-    /*if (!foundTemplate) {
-        // try to guess the template
-        const gt = tfm.guess(model.name);
-        if (gt == "none") {
-            throw new Error(`Unable to guess the template for ${model.name}: please provide a template name: --tpl templatename`)
-        }
-        model.template = gt;
-        foundTemplate = true;
-    }
-    if (!model?.template) {
-        throw new Error(`No template found`)
-    }*/
-    //model.inferParams = ip;
-    // use default ctx if the model is not from defined in the task file
-    if (!model?.ctx || !isModelFromTaskFile) {
-        model.ctx = taskSpec.ctx;
-    }
-    //model.inferParams = ip;
-    return model;
-}
-function mergeConfOptions(conf, options) {
-    const res = conf;
-    for (const [k, v] of Object.entries(options)) {
-        if (k == "inferParams") {
-            continue;
-        }
-        res[k] = v;
-    }
-    return res;
-}
-function mergeInferParams(userInferParams, taskInferParams) {
-    const ip = taskInferParams;
-    //console.log("IP", ip);
-    for (const [k, v] of Object.entries(userInferParams)) {
-        ip[k] = v;
-    }
-    return ip;
-}
-export { mergeConfOptions, mergeInferParams, configureTaskModel, };

package/dist/cmd/lib/tasks/read.d.ts

@@ -1,14 +0,0 @@
-import { Agent } from "@agent-smith/agent";
-import { ModelSpec } from "@agent-smith/task";
-import { NodeTask } from "@agent-smith/nodetask";
-import { McpClient } from "../mcp.js";
-import type { LmTaskConfig } from "../../../interfaces.js";
-declare function readTask(name: string, payload: Record<string, any>, options: Record<string, any>, agent: Agent): Promise<{
-    task: NodeTask;
-    model: ModelSpec;
-    conf: LmTaskConfig;
-    vars: Record<string, any>;
-    mcpServers: Array<McpClient>;
-    taskDir: string;
-}>;
-export { readTask };

package/dist/cmd/lib/tasks/read.js

@@ -1,186 +0,0 @@
-import path from "path";
-import { NodeTask } from "@agent-smith/nodetask";
-import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
-import { readTool } from "../../../db/read.js";
-import { executeAction } from "../actions/cmd.js";
-import { McpClient } from "../mcp.js";
-import { parseTaskConfigOptions } from "../options_parsers.js";
-import { executeWorkflow } from "../workflows/cmd.js";
-import { executeTask } from "./cmd.js";
-import { configureTaskModel, mergeInferParams } from "./conf.js";
-import { openTaskSpec } from "./utils.js";
-import { confirmToolUsage } from "../tools.js";
-async function readTask(name, payload, options, agent) {
-    if (options?.debug) {
-        console.log("Task", name);
-        console.log("Payload:", payload);
-        console.log("Task options:", options);
-    }
-    const { taskFileSpec, taskPath } = openTaskSpec(name, options?.isAgent);
-    const taskDir = path.dirname(taskPath);
-    // merge passed options from payload
-    const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
-    const conf = parseTaskConfigOptions(opts);
-    if (options?.debug) {
-        console.log("Task conf:", conf);
-        conf.debug = true;
-    }
-    conf.inferParams = mergeInferParams(conf.inferParams, taskFileSpec.inferParams ?? {});
-    const model = configureTaskModel(conf, taskFileSpec);
-    if (options?.ctx) {
-        model.ctx = options.ctx;
-    }
-    // vars
-    const taskSpec = taskFileSpec;
-    let vars = {};
-    if (taskSpec?.variables?.optional) {
-        for (const k of Object.keys(taskSpec.variables.optional)) {
-            if (k in options) {
-                vars[k] = options[k];
-            }
-            else if (k in payload) {
-                vars[k] = payload[k];
-            }
-        }
-    }
-    if (taskSpec?.variables?.required) {
-        for (const k of Object.keys(taskSpec.variables.required)) {
-            //console.log("TASK V required:", Object.keys(taskSpec.variables.required), "/", k in options, "/", k in payload);
-            if (k in options) {
-                vars[k] = options[k];
-            }
-            else if (k in payload) {
-                vars[k] = payload[k];
-            }
-        }
-    }
-    const mcpServers = new Array();
-    if (!taskSpec?.tools) {
-        taskSpec.tools = [];
-    }
-    const mcpServersArgs = {};
-    if (options?.mcp) {
-        options.mcp.forEach(v => {
-            const s = v.split(":");
-            if (s.length < 2) {
-                throw new Error(`Malformed mcp option ${v}: use --mcp servername:arg1,arg2`);
-            }
-            const sn = s[0];
-            const sa = s[1];
-            const _margs = sa.split(",");
-            mcpServersArgs[sn] = _margs;
-        });
-        if (options?.debug) {
-            console.log("Opening", options.mcp.length, "server(s)");
-        }
-    }
-    // mcp tools
-    if (taskFileSpec?.mcp) {
-        for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
-            //console.log("MCP TOOL:", tool)
-            const authorizedTools = new Array();
-            const askUserTools = new Array();
-            if (tool?.tools) {
-                tool.tools.forEach(t => {
-                    let tn = t;
-                    if (t.endsWith("?")) {
-                        tn = t.slice(0, -1);
-                        askUserTools.push(tn);
-                    }
-                    authorizedTools.push(tn);
-                });
-            }
-            const margs = tool.arguments;
-            if (servername in mcpServersArgs) {
-                margs.push(...mcpServersArgs[servername]);
-            }
-            const mcp = new McpClient(servername, tool.command, tool.arguments, authorizedTools.length > 0 ? authorizedTools : null, askUserTools.length > 0 ? askUserTools : null);
-            //console.log("MCP", mcp);
-            mcpServers.push(mcp);
-            /*await mcp.start();
-            const tools = await mcp.extractTools();
-            tools.forEach(t => taskSpec.tools?.push(t))*/
-        }
-    }
-    // tools
-    //console.log("Task tools list:", taskSpec.toolsList);
-    if (taskSpec.toolsList) {
-        for (const rawToolName of taskSpec.toolsList) {
-            let toolName = rawToolName;
-            let autoRunTool = true;
-            if (rawToolName.endsWith("?")) {
-                autoRunTool = false;
-                toolName = rawToolName.slice(0, -1);
-            }
-            const { found, tool, type } = readTool(toolName);
-            if (!found) {
-                throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
-            }
-            //console.log("Tool found:", toolName, tool);
-            const quiet = !options?.debug;
-            const lmTool = {
-                ...tool,
-                execute: async (params) => {
-                    //console.log("EXEC TOOL:", type, toolName, params);
-                    switch (type) {
-                        case "action":
-                            const res = await executeAction(toolName, params, options, quiet);
-                            return res;
-                        case "task":
-                            options.isToolCall = true;
-                            options.isAgent = false;
-                            const tres = await executeTask(toolName, params, options);
-                            options.isToolCall = false;
-                            //console.log("WFTRESP", tres.answer.text);
-                            return tres.answer.text;
-                        case "agent":
-                            options.isToolCall = true;
-                            options.isAgent = true;
-                            const agres = await executeTask(toolName, params, options);
-                            options.isAgent = false;
-                            options.isToolCall = false;
-                            //console.log("WFTRESP", tres.answer.text);
-                            if (agres?.answer?.text) {
-                                return agres.answer.text;
-                            }
-                            return agres;
-                        case "workflow":
-                            options.isToolCall = true;
-                            const wres = await executeWorkflow(toolName, params, options);
-                            options.isToolCall = false;
-                            return wres;
-                        default:
-                            throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
-                    }
-                }
-            };
-            if (!autoRunTool) {
-                lmTool.canRun = options?.confirmToolUsage ?
-                    options.confirmToolUsage :
-                    confirmToolUsage;
-            }
-            taskSpec.tools.push(lmTool);
-        }
-        delete taskSpec.toolsList;
-    }
-    ;
-    if (options?.chatMode) {
-        taskSpec.prompt = "{prompt}";
-    }
-    //console.log("TASK SPEC:", JSON.stringify(taskSpec, null, "  "));
-    const task = new NodeTask(agent, taskSpec);
-    //task.addTools(taskSpec.tools);
-    //console.log("TASK TOOLS", task.agent.tools);
-    // check for grammars
-    if (model?.inferParams?.tsGrammar) {
-        //console.log("TSG");
-        model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
-        delete model.inferParams.tsGrammar;
-    }
-    /*if (options?.debug) {
-        console.log("Task model:", model);
-        //console.log("Task vars:", vars);
-    }*/
-    return { task, model, conf, vars, mcpServers, taskDir };
-}
-export { readTask };

package/dist/cmd/lib/tasks/utils.d.ts

@@ -1,8 +0,0 @@
-import { LmTaskFileSpec } from "../../../interfaces.js";
-declare function openTaskSpec(name: string, isAgent?: boolean): {
-    taskFileSpec: LmTaskFileSpec;
-    taskPath: string;
-};
-declare function getInputFromOptions(options: Record<string, any>): Promise<string | null>;
-declare function getTaskPrompt(name: string, args: Array<string>, options: Record<string, any>): Promise<string>;
-export { getTaskPrompt, getInputFromOptions, openTaskSpec, };

package/dist/cmd/lib/tasks/utils.js

@@ -1,48 +0,0 @@
-import YAML from 'yaml';
-import { readClipboard } from '../../../cmd/sys/clipboard.js';
-import { readTask } from "../../../cmd/sys/read_task.js";
-import { getFeatureSpec } from "../../../state/features.js";
-import { runtimeDataError } from '../user_msgs.js';
-import { readPromptFile } from '../utils.js';
-function openTaskSpec(name, isAgent = false) {
-    const ft = isAgent ? "agent" : "task";
-    const { found, path } = getFeatureSpec(name, ft);
-    if (!found) {
-        throw new Error(`${ft} ${name} not found`);
-    }
-    const res = readTask(path);
-    if (!res.found) {
-        throw new Error(`${ft} ${name}, ${path} not found`);
-    }
-    const taskFileSpec = YAML.parse(res.ymlTask);
-    taskFileSpec.name = name;
-    return { taskFileSpec: taskFileSpec, taskPath: 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 getTaskPrompt(name, args, options) {
-    const ic = await getInputFromOptions(options);
-    if (ic) {
-        return ic;
-    }
-    let pr;
-    if (args[0] !== undefined) {
-        pr = args[0];
-    }
-    else {
-        runtimeDataError(options?.isAgent ? "agent" : "task", name, "provide a prompt or use input options");
-        throw new Error();
-    }
-    return pr;
-}
-export { getTaskPrompt, getInputFromOptions, openTaskSpec, };

package/dist/cmd/lib/tools.d.ts

@@ -1,15 +0,0 @@
-import { FeatureExtension } from '../../interfaces.js';
-import { type ToolCallSpec } from '@locallm/types';
-declare function confirmToolUsage(toolCall: ToolCallSpec): Promise<boolean>;
-declare function extractTaskToolDocAndVariables(name: string, ext: FeatureExtension, dirPath: string): {
-    toolDoc: string;
-    variables: {
-        required: Array<string>;
-        optional: Array<string>;
-    };
-};
-declare function extractToolDoc(name: string, ext: FeatureExtension, dirPath: string): {
-    found: boolean;
-    toolDoc: string;
-};
-export { extractToolDoc, extractTaskToolDocAndVariables, confirmToolUsage, };

package/dist/cmd/lib/tools.js

@@ -1,147 +0,0 @@
-import YAML from 'yaml';
-import * as fs from 'fs';
-import { readYmlFile } from '../sys/read_yml_file.js';
-import { confirm } from '@inquirer/prompts';
-import colors from "ansi-colors";
-async function confirmToolUsage(toolCall) {
-    console.log("Tool call:", colors.bold(toolCall.name));
-    if (toolCall?.arguments) {
-        console.log("Arguments:", toolCall.arguments);
-    }
-    else {
-        console.log("No arguments");
-    }
-    return await confirm({ message: `Execute tool ${toolCall.name}?` });
-}
-function _extractToolDoc(filePath, startComment, endComment) {
-    try {
-        const fileContent = fs.readFileSync(filePath, 'utf-8');
-        const startMarker = startComment + '\n# tool';
-        if (!fileContent.startsWith(startMarker)) {
-            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();
-        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 _parseTaskVariables(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 extractTaskToolDocAndVariables(name, ext, dirPath) {
-    const fp = dirPath + "/" + name + "." + ext;
-    const { data, found } = readYmlFile(fp);
-    const res = { variables: { required: new Array(), optional: new Array() }, toolDoc: "" };
-    // tools
-    let tspec;
-    if (!found) {
-        throw new Error(`extractTaskToolDocAndVariables: file ${fp} not found`);
-    }
-    if (data?.tool) {
-        data.tool.name = name;
-        tspec = data.tool;
-        res.toolDoc = JSON.stringify(tspec, null, "  ");
-    }
-    // variables
-    const { required, optional } = _parseTaskVariables(data);
-    res.variables.required = required;
-    res.variables.optional = optional;
-    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, "  ");
-    }
-    else {
-        return { found: false, toolDoc: "" };
-    }
-    return { found: true, toolDoc: spec };
-}
-export { extractToolDoc, extractTaskToolDocAndVariables, confirmToolUsage, };

package/dist/cmd/lib/utils.d.ts

@@ -1,3 +0,0 @@
-declare function readPromptFile(): string;
-declare function processOutput(res: any): Promise<void>;
-export { processOutput, readPromptFile, };

package/dist/cmd/lib/utils.js

@@ -1,54 +0,0 @@
-import { formatMode, initFilepaths, outputMode, promptfilePath } from "../../state/state.js";
-import { writeToClipboard } from "../sys/clipboard.js";
-import { readFile } from "../sys/read.js";
-import { splitThinking } from "../../utils/text.js";
-import { runtimeError } from "./user_msgs.js";
-import { marked } from 'marked';
-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?.answer?.text) {
-            //console.log("****************** TPL", res?.answer?.template);
-            if (res?.template?.tags?.think) {
-                const { finalAnswer } = splitThinking(res.answer.text, res.template.tags.think.start, res.template.tags.think.end);
-                data = finalAnswer;
-            }
-            else {
-                data = res.answer.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());
-        }
-    }
-}
-export { processOutput, readPromptFile, };

package/dist/cmd/lib/workflows/cmd.d.ts

@@ -1,3 +0,0 @@
-declare function executeWorkflow(wname: string, args: any, options?: Record<string, any>): Promise<any>;
-declare function executeWorkflowCmd(name: string, wargs: Array<any>): Promise<any>;
-export { executeWorkflow, executeWorkflowCmd };