tarsk 0.2.5 → 0.3.0

package/dist/api/tools.js

@@ -1,287 +0,0 @@
-import { existsSync, mkdirSync, promises, readdirSync, writeFileSync, } from "fs";
-import { extname, join } from "path";
-import { extensionLess, isEmpty, tarskFolder } from "./utils.js";
-import { logError, logWrite } from "../log/log.js";
-import tsBlankSpace from "ts-blank-space";
-import { loadTools } from "../tools.js";
-import { callFunction } from "../agent/agent.js";
-import { readAsJSONIfExists } from "../utils/files.js";
-import ts, { SyntaxKind } from "typescript";
-import { createTest } from "./test.js";
-export async function api_run_tool(c) {
-    const tool = await c.req.json();
-    logWrite({ type: "api_run_tool", args: { toolName: tool.name } });
-    if (!tool.code) {
-        return c.json({ error: "Tool not found" }, 404);
-    }
-    try {
-        const toolToRun = await getTool(tool.name);
-        const tools = await loadTools(toolJavascriptFilenames(true));
-        const d = tools.find((t) => t.name == toolToRun.name + '.test');
-        const functionName = 'test';
-        if (!d) {
-            throw new Error(`${tool.name} not found`);
-        }
-        if (!d.functionNames.includes(functionName)) {
-            throw new Error(`${tool.name} function "${functionName}" not found (reload?)`);
-        }
-        const output = await callFunction(d.functionMap[functionName]);
-        return c.json({ output, js: 'test();' });
-    }
-    catch (e) {
-        return c.json({ output: `${e}`, js: '' });
-    }
-}
-export async function api_save_tool(c) {
-    const tool = await c.req.json();
-    if (tool.name == "") {
-        tool.name = tool.title;
-    }
-    const title = tool.title;
-    const code = tool.code;
-    let test = tool.test ?? "";
-    const name = tool.name.toLowerCase().replaceAll(" ", "_");
-    if (!title || !code || !name) {
-        return c.json({ error: "Title and code are required" }, 400);
-    }
-    const meta = { title, name };
-    const jsCode = tsBlankSpace(tool.code ?? "", (e) => {
-        logError({ type: "failed_ts_to_js_code", args: e });
-    });
-    const testCode = tsBlankSpace(tool.test ?? "", (e) => {
-        logError({ type: "failed_ts_to_js_test", args: e });
-    });
-    const filename = name.replace(/\s+/g, "_").toLowerCase();
-    const srcPath = join(toolsSrcFolder(), `${filename}.ts`);
-    const jsCodePath = join(toolsJSFolder(), `${filename}.js`);
-    const defPath = join(toolsJSFolder(), `${filename}.js.definition.json`);
-    const testPath = join(toolsSrcFolder(), `${filename}.test.ts`);
-    const jsTestPath = join(toolsJSFolder(), `${filename}.test.js`);
-    const metaPath = join(toolsSrcFolder(), `${filename}.json`);
-    const currentMeta = readAsJSONIfExists(metaPath);
-    if (currentMeta) {
-        meta.revision = (currentMeta.revision ?? 1) + 1;
-    }
-    const missingData = {
-        missingParameters: [],
-        missingFunctions: []
-    };
-    const definition = await inspectCode(srcPath, missingData);
-    logWrite({ type: "api_save_tool_check_test", args: { test } });
-    if (isEmpty(test)) {
-        test = await createTest(definition, `${filename}.js`, code);
-    }
-    writeFileSync(srcPath, code, "utf-8");
-    writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
-    writeFileSync(defPath, JSON.stringify(definition, null, 2), "utf-8");
-    writeFileSync(testPath, test, "utf-8");
-    writeFileSync(jsCodePath, jsCode, "utf-8");
-    writeFileSync(jsTestPath, testCode, "utf-8");
-    logWrite({ type: "api_save_tool", args: { test: testPath, code: srcPath, meta: metaPath } });
-    return c.json({
-        message: `Tool saved successfully (${jsCodePath})`,
-        missingParameters: missingData.missingParameters,
-        missingFunctions: missingData.missingFunctions,
-    });
-}
-export async function api_get_tool(c) {
-    const toolName = c.req.param("tool");
-    const tool = await getTool(toolName);
-    console.log(`api_get_tool ${toolName}`);
-    return c.json(tool);
-}
-export async function api_delete_tool(c) {
-    const toolName = c.req.param("tool");
-    await deleteTool(toolName);
-    return c.json({});
-}
-async function deleteTool(name) {
-    console.log(`Deleting tool ${name}`);
-    const toolsFolder = toolsSrcFolder();
-    await promises.rm(join(toolsFolder, `${name}.ts`));
-    await promises.rm(join(toolsFolder, `${name}.test.ts`));
-    await promises.rm(join(toolsFolder, `${name}.json`));
-    await promises.rm(join(toolsJSFolder(), `${name}.js`));
-    await promises.rm(join(toolsJSFolder(), `${name}.test.js`));
-}
-export async function api_get_tools(c) {
-    const fileList = await toolFilenames();
-    const result = [];
-    for (const file of fileList) {
-        const tool = await getTool(file);
-        tool.code = undefined;
-        result.push(tool);
-    }
-    return c.json(result);
-}
-async function toolFilenames() {
-    const toolsFolder = toolsSrcFolder();
-    const files = await promises.readdir(toolsFolder);
-    return files
-        .filter((f) => extname(f) === ".ts" && !f.endsWith(".test.ts"))
-        .map((f) => extensionLess(f));
-}
-function toolsJSFolder() {
-    const folderPath = join(tarskFolder(), ".tools");
-    if (!existsSync(folderPath)) {
-        mkdirSync(folderPath, { recursive: true });
-    }
-    return folderPath;
-}
-export function toolJavascriptFilenames(includeTests) {
-    const files = readdirSync(toolsJSFolder());
-    if (includeTests) {
-        return files
-            .filter((f) => extname(f) === ".js")
-            .map((f) => join(tarskFolder(), ".tools", f));
-    }
-    else {
-        return files
-            .filter((f) => extname(f) === ".js" && !f.endsWith(".test.js"))
-            .map((f) => join(tarskFolder(), ".tools", f));
-    }
-}
-export async function getTool(name) {
-    const toolsFolder = toolsSrcFolder();
-    const code = await readOrEmpty(join(toolsFolder, `${name}.ts`));
-    const test = await readOrEmpty(join(toolsFolder, `${name}.test.ts`));
-    const meta = await readOrEmpty(join(toolsFolder, `${name}.json`));
-    try {
-        const json = meta == '' ? { tile: '', name: '' } : JSON.parse(meta);
-        return { code, title: json.title, name: json.name, test };
-    }
-    catch (e) {
-        console.error(`Failed to parse ${name}.json`, e);
-        return { code, title: "", name, test };
-    }
-}
-function toolsSrcFolder() {
-    const folderPath = join(tarskFolder(), "tools");
-    if (!existsSync(folderPath)) {
-        mkdirSync(folderPath, { recursive: true });
-    }
-    return folderPath;
-}
-async function readOrEmpty(filename) {
-    if (!existsSync(filename)) {
-        return "";
-    }
-    return await promises.readFile(filename, "utf-8");
-}
-export async function inspectCode(filename, missingData) {
-    const code = await readOrEmpty(filename);
-    const tools = [];
-    const sourceFile = ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true);
-    function visit(node) {
-        if ((ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) && node.name) {
-            const parsed = parseJSDoc(node);
-            console.log("Parsed function", parsed);
-            const properties = {};
-            const required = [];
-            node.parameters.forEach(param => {
-                const isOptional = !!param.questionToken || !!param.initializer;
-                if (!isOptional) {
-                    required.push(param.name.getText());
-                }
-                let type = typeName(param.type?.getText());
-                if (param.type?.kind == SyntaxKind.TypeReference) {
-                    type = 'object';
-                }
-                parsed.params;
-                const hasDescription = Object.keys(parsed.params).includes(param.name.getText());
-                const description = hasDescription ? parsed.params[param.name.getText()] : '';
-                if (!hasDescription) {
-                    missingData.missingParameters.push(param.name.escapedText);
-                }
-                properties[param.name.getText()] = {
-                    type,
-                    description
-                };
-                if (type == 'array') {
-                    properties[param.name.getText()].items = {
-                        type: arrayType(param.type?.getText()),
-                    };
-                }
-            });
-            const functionDescription = parsed.description;
-            if (isEmpty(functionDescription)) {
-                missingData.missingFunctions.push(node.name.getText());
-            }
-            tools.push({
-                type: 'function',
-                function: {
-                    name: node.name?.text ?? '',
-                    description: functionDescription,
-                    parameters: {
-                        type: 'object',
-                        properties,
-                        required,
-                    }
-                }
-            });
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    return tools;
-}
-function parseJSDoc(node) {
-    const functionName = node.name?.getText();
-    const jsDoc = ts.getJSDocCommentsAndTags(node);
-    const parsed = {
-        functionName,
-        description: "",
-        params: {},
-    };
-    let info = '';
-    for (const doc of jsDoc) {
-        if (ts.isJSDoc(doc)) {
-            if (doc.comment) {
-                parsed.description = doc.comment.toString();
-            }
-            if (doc.tags) {
-                for (const tag of doc.tags) {
-                    info += ' ' + tag.comment;
-                    if (tag.kind == SyntaxKind.JSDocTag && tag.comment) {
-                        let txt = tag.comment ? tag.comment.toString() : "";
-                        const lines = txt.split(' ');
-                        const paramName = lines[0];
-                        if (txt.startsWith(paramName)) {
-                            txt = txt.substring(paramName.length).trim();
-                        }
-                        if (txt.startsWith('-')) {
-                            txt = txt.substring(1).trim();
-                        }
-                        parsed.params[paramName] = txt;
-                    }
-                    if (tag.kind == SyntaxKind.JSDocFunctionType ||
-                        tag.kind == SyntaxKind.JSDocParameterTag) {
-                        let txt = tag.comment ? tag.comment.toString() : "";
-                        let paramName = tag.name?.escapedText;
-                        if (txt.startsWith(paramName)) {
-                            txt = txt.substring(paramName.length).trim();
-                        }
-                        if (txt.startsWith('-')) {
-                            txt = txt.substring(1).trim();
-                        }
-                        parsed.params[paramName] = txt;
-                    }
-                }
-            }
-        }
-    }
-    return parsed;
-}
-function typeName(name) {
-    if (!name)
-        return 'any';
-    if (name.endsWith('[]')) {
-        return 'array';
-    }
-    return name;
-}
-function arrayType(name) {
-    if (!name)
-        return 'any';
-    return name.replace('[]', '');
-}

package/dist/api/utils.js

@@ -1,18 +0,0 @@
-import { HTTPException } from "hono/http-exception";
-import { homedir } from "os";
-import { extname, join } from "path";
-export function extensionLess(filename) {
-    return filename.substring(0, filename.length - extname(filename).length);
-}
-export function tarskFolder() {
-    return join(homedir(), ".tarsk");
-}
-export function httpValidationErrror(message) {
-    throw new HTTPException(406, { message });
-}
-export function isEmpty(v) {
-    if (v == undefined || v == null || v == "" || v.trim() == "") {
-        return true;
-    }
-    return false;
-}

package/dist/interfaces/meta.js

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

package/dist/interfaces/model.js

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

package/dist/interfaces/settings.js

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

package/dist/log/log.js

@@ -1,33 +0,0 @@
-let logLevel = "debug";
-export function logWrite(l, additionalMessage) {
-    if (logLevel == "none")
-        return;
-    let msg = l.type;
-    if (l.message) {
-        msg += `: ${l.message}`;
-    }
-    if (l.args) {
-        msg += ` ${JSON.stringify(l.args)}`;
-    }
-    l.id = id();
-    console.log(msg);
-}
-export function logStart(l, additionalMessage) {
-    if (logLevel === "none")
-        return;
-    console.time(l.type);
-    logWrite(l, additionalMessage);
-}
-export function logEnd(label) {
-    if (logLevel === "none")
-        return;
-    console.timeEnd(label);
-}
-export function logError(l) {
-    if (logLevel === "none")
-        return;
-    console.error(l);
-}
-function id() {
-    return Math.random().toString().replace(".", "");
-}

package/dist/prompt.js

@@ -1,49 +0,0 @@
-import { completion } from "./agent/agent.js";
-import { loadTools } from "./tools.js";
-import { defaultModel, getSettings } from "./api/settings.js";
-import { toolJavascriptFilenames } from "./api/tools.js";
-import { isEmpty } from "./api/utils.js";
-import { logWrite, logEnd, logStart } from "./log/log.js";
-export async function prompt(content, promptOptions) {
-    const settings = await getSettings();
-    let apiKey = settings.tarskApiKey;
-    const options = {
-        baseUrl: isEmpty(settings.apiURL) ? "https://api.tarsk.io/api/v1" : settings.apiURL,
-        apiKey,
-    };
-    const messages = [];
-    if (promptOptions?.firstMessage) {
-        messages.push(promptOptions.firstMessage);
-    }
-    messages.push({ role: "user", content });
-    const model = isEmpty(settings.defaultModel)
-        ? defaultModel
-        : settings.defaultModel;
-    logWrite({ type: "prompt", args: content }, `The model is ${model}`);
-    const filenames = toolJavascriptFilenames(false);
-    let tools = [];
-    if (!promptOptions?.ignoreTools) {
-        logStart({ type: "load_tools", args: filenames });
-        tools = await loadTools(filenames);
-        logEnd("load_tools");
-    }
-    const request = { model, tools, messages };
-    try {
-        const response = await completion(request, options);
-        logWrite({ type: "completion_response", args: response });
-        logWrite({ type: "message", args: response?.choices[0].message });
-        return response?.choices[0].message.content;
-    }
-    catch (e) {
-        return friendlyError(`${e}`, settings);
-    }
-}
-function friendlyError(e, settings) {
-    if (e.startsWith("Error: No endpoints found that support tool use")) {
-        return `The model "${settings.defaultModel}" does not support tool use. Please select a different model (A good default is ${defaultModel}).`;
-    }
-    if (e.startsWith("Error: No auth credentials found")) {
-        return `The API key is invalid. Please check your account and get a new key.`;
-    }
-    return e;
-}

package/dist/tools.js

@@ -1,84 +0,0 @@
-import { logWrite, logEnd, logError, logStart } from "./log/log.js";
-import { getPathWithoutExtension, readAsJSONIfExists } from "./utils/files.js";
-export async function loadTools(modulePaths) {
-    const tools = [];
-    logWrite({
-        type: "load_tools",
-        args: modulePaths,
-    }, `modulePaths is "${modulePaths.join(", ")}"`);
-    for (const modulePath of modulePaths) {
-        logWrite({ type: "getTool", args: modulePath });
-        if (modulePath == "") {
-            logError({ type: "getTool", args: "Empty modulePath" });
-            continue;
-        }
-        else {
-            const tool = await inspectTool(modulePath);
-            tools.push(tool);
-        }
-    }
-    return tools;
-}
-function findMetaData(modulePath) {
-    let metaPath = (getPathWithoutExtension(modulePath) + ".json").replace('.tools', 'tools');
-    const meta = readAsJSONIfExists(metaPath);
-    if (meta)
-        return meta;
-    metaPath = metaPath.replace('.test', '');
-    const meta2 = readAsJSONIfExists(metaPath);
-    if (meta2)
-        meta2.name = meta2.name + '.test';
-    if (meta2)
-        return meta2;
-}
-async function inspectTool(modulePath) {
-    const result = {
-        functionNames: [],
-        functionMap: undefined,
-        definition: undefined,
-        name: undefined,
-        path: modulePath,
-        revision: undefined
-    };
-    logStart({ type: "load_tool", args: { modulePath } }, `The modulePath is "${modulePath}"`);
-    try {
-        const meta = findMetaData(modulePath);
-        result.revision = meta?.revision;
-        result.name = meta?.name;
-        const isTest = modulePath.endsWith(".test.js");
-        const query = isTest ? `?${Math.random()}` : `?${result.revision}`;
-        const myModule = await import(modulePath + query);
-        try {
-            result.functionNames = Object.keys(myModule);
-            result.functionMap = {};
-            for (const func of result.functionNames) {
-                logWrite({ type: "load_tool_function", args: { foundFunction: func } });
-                result.functionMap[func] = myModule[func];
-            }
-        }
-        catch (e) {
-            throw new Error(`Error loading Map from ${modulePath}: ${e}`);
-        }
-        try {
-            if (!isTest) {
-                result.definition = getDefinition(modulePath);
-            }
-        }
-        catch (e) {
-            throw new Error(`Error loading the agent map from ${modulePath}: ${e}`);
-        }
-        return result;
-    }
-    catch (e) {
-        logError({ type: "load_tool_error", args: e });
-        throw new Error(`load_tool_error ${modulePath}: ${e}`);
-    }
-    finally {
-        logEnd("load_tool");
-        logWrite({ type: 'load_tool', args: { result } });
-    }
-}
-function getDefinition(modulePath) {
-    const filename = modulePath + '.definition.json';
-    return readAsJSONIfExists(filename);
-}

package/dist/utils/files.js

@@ -1,14 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-export function getPathWithoutExtension(path) {
-    const lastDotIndex = path.lastIndexOf(".");
-    if (lastDotIndex === -1) {
-        return path;
-    }
-    return path.slice(0, lastDotIndex);
-}
-export function readAsJSONIfExists(path) {
-    if (existsSync(path)) {
-        const data = readFileSync(path, "utf-8");
-        return JSON.parse(data);
-    }
-}

package/dist/utils/json-file.js

@@ -1,28 +0,0 @@
-import { join } from "path";
-import { tarskFolder } from "../api/utils.js";
-import { existsSync, mkdir, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { decryptString, encryptString } from "../api/encryption.js";
-export function getJSON(name, defaultValue) {
-    const filename = join(tarskFolder(), name + '.json');
-    if (!existsSync(filename)) {
-        if (!existsSync(tarskFolder())) {
-            mkdirSync(tarskFolder(), { recursive: true });
-        }
-        setJSON(name, defaultValue);
-        return defaultValue;
-    }
-    else {
-        try {
-            const data = readFileSync(filename, 'utf-8');
-            return JSON.parse(decryptString(data));
-        }
-        catch (e) {
-            setJSON(name, defaultValue);
-            return defaultValue;
-        }
-    }
-}
-export function setJSON(name, value) {
-    const filename = join(tarskFolder(), name + '.json');
-    writeFileSync(filename, encryptString(JSON.stringify(value)));
-}

package/dist/utils/strip-markdown.js

@@ -1,5 +0,0 @@
-export function stripMarkdown(markdown) {
-    const lines = markdown.split("\n");
-    const strippedLines = lines.filter(line => !line.startsWith("```"));
-    return strippedLines.join("\n").trim();
-}