tarsk 0.0.1

package/README.md

@@ -0,0 +1,9 @@
+# Tarsk
+
+Tarsk is an AI tool editor.
+
+Run `npx tarsk`
+
+## Details
+
+This will serve at `http://localhost:4021`

package/dist/agent/agent.js

@@ -0,0 +1,117 @@
+import { logWrite, logEnd, logError, logStart } from "../log/log.js";
+export async function completion(request, options) {
+    // Get the full list of tool definitions
+    const tools = request.tools.map(tool => JSON.parse(JSON.stringify(tool.definition)) ?? []);
+    // Create the object without the functions etc of the request
+    const req = {
+        model: request.model,
+        tools,
+        messages: request.messages,
+    };
+    logStart({ type: 'completion', args: '' });
+    let repeating;
+    let count = 0;
+    let response = {};
+    do {
+        repeating = false;
+        count++;
+        logStart({ type: `completion_request_${count}`, args: request });
+        response = await call(options, req);
+        logEnd(`completion_request_${count}`);
+        if (response.error) {
+            const message = JSON.stringify(response.error.metadata);
+            logError({ type: 'completion_error', message, args: { ...response.error } });
+            throw new Error(response.error.message);
+        }
+        for (const choice of response.choices) {
+            // Inject the response message back into the request so the LLM knows for next round                        
+            logWrite({ type: 'inject_choice', args: choice });
+            request.messages.push(cleanedMessage(choice.message));
+            if (choice.finish_reason == 'tool_calls') {
+                logStart({ type: 'tool_calls', args: choice.message.tool_calls });
+                const newMessages = await callTools(choice.message.tool_calls ?? [], request);
+                request.messages.push(...newMessages);
+                logEnd('tool_calls');
+                // Do another loop if requested
+                repeating = newMessages.length > 0;
+            }
+        }
+    } while (repeating);
+    logEnd('completion');
+    return response;
+}
+// This gets rid of the fields that the LLM throws errors on
+function cleanedMessage(message) {
+    const cleaned = JSON.parse(JSON.stringify(message));
+    delete (cleaned.reasoning);
+    delete (cleaned.refusal);
+    for (const call of cleaned.tool_calls ?? []) {
+        delete (call.index);
+    }
+    return cleaned;
+}
+export async function callTools(toolCalls, request) {
+    const newMessages = [];
+    for (const toolCall of toolCalls) {
+        const toolName = toolCall.function.name;
+        const toolArgs = JSON.parse(toolCall.function.arguments);
+        // Find the tool by function name
+        let found;
+        let toolMap;
+        for (const tool of request.tools) {
+            for (const definition of tool.definition ?? []) {
+                if (definition.function.name == toolName) {
+                    found = definition;
+                    toolMap = tool.toolMap;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            throw new Error(`Tool ${toolName} not found`);
+        }
+        if (!toolMap) {
+            throw new Error(`Tool map for ${toolName} not found`);
+        }
+        // TODO: Promise all the tool calls
+        if (!toolMap[toolName]) {
+            throw new Error(`Tool ${toolName} not found in tool map. Check the function name in the definition matches exactly to the name of the function`);
+        }
+        logStart({ type: `tool_call_${toolName}`, args: { toolName, toolArgs } });
+        try {
+            const toolResponse = await toolMap[toolName](...Object.values(toolArgs));
+            newMessages.push({
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                //toolCallId: toolCall.id,
+                name: toolName,
+                content: JSON.stringify(toolResponse),
+            });
+            logWrite({ type: 'tool_call_response', args: { toolName, toolResponse }, message: JSON.stringify(toolResponse) });
+        }
+        catch (error) {
+            var err = new Error();
+            logWrite({ type: 'tool_call_error', args: { toolName, error }, message: err.stack?.toString() });
+            throw new Error(`Error calling tool ${toolName}: ${error}`);
+        }
+        finally {
+            logEnd(`tool_call_${toolName}`);
+        }
+    }
+    return newMessages;
+}
+async function call(options, request) {
+    const response = await fetch(`${options.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Authorization': 'Bearer ' + options.apiKey,
+            'HTTP-Referer': 'https://webnative.dev', // Optional. Site URL for rankings on openrouter.ai.
+            'X-Title': 'Tarsk', // Optional. Site title for rankings on openrouter.ai.
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(request)
+    });
+    const text = await response.text();
+    const json = JSON.parse(text);
+    return json;
+}

package/dist/agent/interfaces.js

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

package/dist/agent/tools.js

@@ -0,0 +1,77 @@
+import { logWrite, logEnd, logError, logStart } from "../log/log.js";
+const weakModules = new WeakMap();
+async function importWeak(modulePath, keyObject) {
+    if (weakModules.has(keyObject)) {
+        return weakModules.get(keyObject);
+    }
+    const module = await import(modulePath);
+    weakModules.set(keyObject, module);
+    return module;
+}
+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 getTool(modulePath);
+            tools.push(tool);
+        }
+    }
+    return tools;
+}
+// async function importFromMemory(moduleCode: string) {
+//   const module = new Function(
+//     "exports",
+//     "module",
+//     "require",
+//     "__filename",
+//     "__dirname",
+//     moduleCode
+//   );
+//   const exports = {};
+//   const moduleObj = { exports: exports };
+//   module(exports, moduleObj, require, null, null);
+//   return moduleObj.exports;
+// }
+// async function importModule(code: string) {
+//   const myModule = await importFromMemory(code);
+//   //console.log(myModule.hello()); // Output: Hello from memory!
+// }
+// eg modulePath = './tools/books.js'
+async function getTool(modulePath) {
+    const result = {
+        key: {},
+        toolMap: undefined,
+        definition: undefined,
+    };
+    // When 'key' is no longer referenced and garbage collected,
+    // the module './myModule.js' associated with it in 'weakModules'
+    // will also be eligible for garbage collection.
+    logStart({ type: "load_tool", args: { modulePath } }, `The modulePath is "${modulePath}"`);
+    try {
+        const myModule = await importWeak(modulePath, result.key);
+        try {
+            result.toolMap = myModule.toolMap;
+            result.definition = myModule.default();
+            return result;
+        }
+        catch (e) {
+            throw new Error(`Error loading tool from ${modulePath}: ${e}`);
+        }
+    }
+    catch (e) {
+        logError({ type: "load_tool_error", args: e });
+    }
+    finally {
+        logEnd("load_tool");
+    }
+    throw new Error(`Error loading tool from ${modulePath}`);
+}

package/dist/api/encryption.js

@@ -0,0 +1,53 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { hostname, machine } from "os";
+export function encryptString(text) {
+    let id = `${machineIdSync()}11de20da-f6cf-4b85-b630-555fc6e8b881`;
+    return encrypt(text, id);
+}
+export function decryptString(text) {
+    try {
+        let id = `${machineIdSync()}11de20da-f6cf-4b85-b630-555fc6e8b881`;
+        return decrypt(text, id);
+    }
+    catch (e) {
+        return "";
+    }
+}
+function machineIdSync() {
+    return machine() + hostname();
+}
+const algorithm = "aes-256-cbc";
+const ivLength = 16; // AES block size in bytes
+/**
+ * Encrypts a string using AES-256-CBC and returns base64-encoded result.
+ * @param text - The plain text to encrypt.
+ * @param passPhrase - The secret passphrase used to generate the encryption key.
+ * @returns A base64 string containing IV and encrypted data, separated by a colon.
+ */
+function encrypt(text, passPhrase) {
+    const iv = randomBytes(ivLength);
+    const key = scryptSync(passPhrase, "salt", 32); // 256-bit key
+    const cipher = createCipheriv(algorithm, key, iv);
+    let encrypted = cipher.update(text, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    const encryptedData = `${iv.toString("base64")}:${encrypted}`;
+    return encryptedData;
+}
+/**
+ * Decrypts a base64-encoded string using AES-256-CBC.
+ * @param encryptedData - The base64-encoded encrypted data (with IV).
+ * @param passPhrase - The secret passphrase used to generate the decryption key.
+ * @returns The decrypted plain text.
+ */
+function decrypt(encryptedData, passPhrase) {
+    const [ivBase64, encryptedBase64] = encryptedData.split(":");
+    if (!ivBase64 || !encryptedBase64) {
+        throw new Error("Invalid encrypted data format");
+    }
+    const iv = Buffer.from(ivBase64, "base64");
+    const key = scryptSync(passPhrase, "salt", 32);
+    const decipher = createDecipheriv(algorithm, key, iv);
+    let decrypted = decipher.update(encryptedBase64, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+}

package/dist/api/models.js

@@ -0,0 +1,162 @@
+export async function api_get_models(c) {
+    const res = await fetch("https://openrouter.ai/api/v1/models");
+    const data = await res.json();
+    const models = [];
+    for (const model of data.data) {
+        if (hasTools(model.id)) {
+            models.push({
+                id: model.id,
+                description: model.description,
+                name: model.name,
+                type: model.architecture.tokenizer,
+                priceM: totalPrice(model.pricing),
+                price: model.pricing.prompt == "0" && model.pricing.completion == "0"
+                    ? ""
+                    : `($${totalPrice(model.pricing).toFixed(2)}m)`,
+            });
+        }
+    }
+    return c.json(models);
+}
+function totalPrice(price) {
+    const total = v(price.prompt) + v(price.completion);
+    return total * 1000000;
+}
+function promptPrice(price) {
+    const total = v(price.prompt);
+    return total * 1000000;
+}
+function completionPrice(price) {
+    const total = v(price.completion);
+    return total * 1000000;
+}
+function v(s) {
+    if (!s)
+        return 0;
+    return Number(s);
+}
+function hasTools(model) {
+    return [
+        "google/gemini-2.5-pro-preview-03-25",
+        "google/gemini-2.5-flash-preview",
+        "google/gemini-2.5-flash-preview:thinking",
+        "openai/o4-mini-high",
+        "openai/o3",
+        "openai/o4-mini",
+        "openai/gpt-4.1",
+        "openai/gpt-4.1-mini",
+        "openai/gpt-4.1-nano",
+        "x-ai/grok-3-beta",
+        "meta-llama/llama-4-maverick",
+        "meta-llama/llama-4-scout",
+        "all-hands/openhands-lm-32b-v0.1",
+        "mistral/ministral-8b",
+        "google/gemini-2.5-pro-exp-03-25:free",
+        "deepseek/deepseek-chat-v3-0324",
+        "mistralai/mistral-small-3.1-24b-instruct:free",
+        "mistralai/mistral-small-3.1-24b-instruct",
+        "ai21/jamba-1.6-large",
+        "ai21/jamba-1.6-mini",
+        "qwen/qwq-32b",
+        "openai/gpt-4.5-preview",
+        "google/gemini-2.0-flash-lite-001",
+        "anthropic/claude-3.7-sonnet",
+        "anthropic/claude-3.7-sonnet:thinking",
+        "anthropic/claude-3.7-sonnet:beta",
+        "mistralai/mistral-saba",
+        "openai/o3-mini-high",
+        "google/gemini-2.0-flash-001",
+        "qwen/qwen-turbo",
+        "qwen/qwen-plus",
+        "qwen/qwen-max",
+        "openai/o3-mini",
+        "mistralai/mistral-small-24b-instruct-2501",
+        "deepseek/deepseek-r1-distill-llama-70b",
+        "deepseek/deepseek-r1",
+        "mistralai/codestral-2501",
+        "deepseek/deepseek-chat",
+        "openai/o1",
+        "x-ai/grok-2-1212",
+        "google/gemini-2.0-flash-exp:free",
+        "meta-llama/llama-3.3-70b-instruct",
+        "amazon/nova-lite-v1",
+        "amazon/nova-micro-v1",
+        "amazon/nova-pro-v1",
+        "openai/gpt-4o-2024-11-20",
+        "mistralai/mistral-large-2411",
+        "mistralai/mistral-large-2407",
+        "mistralai/pixtral-large-2411",
+        "anthropic/claude-3.5-haiku:beta",
+        "anthropic/claude-3.5-haiku",
+        "anthropic/claude-3.5-haiku-20241022:beta",
+        "anthropic/claude-3.5-haiku-20241022",
+        "anthropic/claude-3.5-sonnet:beta",
+        "anthropic/claude-3.5-sonnet",
+        "x-ai/grok-beta",
+        "mistralai/ministral-8b",
+        "mistralai/ministral-3b",
+        "nvidia/llama-3.1-nemotron-70b-instruct",
+        "google/gemini-flash-1.5-8b",
+        "meta-llama/llama-3.2-3b-instruct",
+        "qwen/qwen-2.5-72b-instruct",
+        "mistralai/pixtral-12b",
+        "cohere/command-r-plus-08-2024",
+        "cohere/command-r-08-2024",
+        "google/gemini-flash-1.5-8b-exp",
+        "ai21/jamba-1-5-mini",
+        "ai21/jamba-1-5-large",
+        "microsoft/phi-3.5-mini-128k-instruct",
+        "nousresearch/hermes-3-llama-3.1-70b",
+        "openai/gpt-4o-2024-08-06",
+        "meta-llama/llama-3.1-8b-instruct",
+        "meta-llama/llama-3.1-405b-instruct",
+        "meta-llama/llama-3.1-70b-instruct",
+        "mistralai/codestral-mamba",
+        "mistralai/mistral-nemo",
+        "openai/gpt-4o-mini",
+        "openai/gpt-4o-mini-2024-07-18",
+        "anthropic/claude-3.5-sonnet-20240620:beta",
+        "anthropic/claude-3.5-sonnet-20240620",
+        "mistralai/mistral-7b-instruct:free",
+        "mistralai/mistral-7b-instruct",
+        "mistralai/mistral-7b-instruct-v0.3",
+        "microsoft/phi-3-mini-128k-instruct",
+        "microsoft/phi-3-medium-128k-instruct",
+        "google/gemini-flash-1.5",
+        "openai/gpt-4o",
+        "openai/gpt-4o:extended",
+        "openai/gpt-4o-2024-05-13",
+        "meta-llama/llama-3-8b-instruct",
+        "meta-llama/llama-3-70b-instruct",
+        "mistralai/mixtral-8x22b-instruct",
+        "google/gemini-pro-1.5",
+        "openai/gpt-4-turbo",
+        "cohere/command-r-plus",
+        "cohere/command-r-plus-04-2024",
+        "cohere/command-r",
+        "anthropic/claude-3-haiku:beta",
+        "anthropic/claude-3-haiku",
+        "anthropic/claude-3-opus:beta",
+        "anthropic/claude-3-opus",
+        "anthropic/claude-3-sonnet:beta",
+        "anthropic/claude-3-sonnet",
+        "cohere/command-r-03-2024",
+        "mistralai/mistral-large",
+        "openai/gpt-3.5-turbo-0613",
+        "openai/gpt-4-turbo-preview",
+        "mistralai/mistral-medium",
+        "mistralai/mistral-small",
+        "mistralai/mistral-tiny",
+        "mistralai/mixtral-8x7b-instruct",
+        "openai/gpt-3.5-turbo-1106",
+        "openai/gpt-4-1106-preview",
+        "mistralai/mistral-7b-instruct-v0.1",
+        "openai/gpt-3.5-turbo-16k",
+        "openai/gpt-4-32k",
+        "openai/gpt-4-32k-0314",
+        "openai/gpt-3.5-turbo",
+        "openai/gpt-3.5-turbo-0125",
+        "openai/gpt-4",
+        "openai/gpt-4-0314",
+    ].includes(model);
+}

package/dist/api/prompt.js

@@ -0,0 +1,12 @@
+import { prompt } from "../prompt.js";
+import { logWrite } from "../log/log.js";
+export async function api_prompt(c) {
+    const body = await c.req.json();
+    logWrite({ type: 'prompt', args: body });
+    const question = body.prompt;
+    if (!question) {
+        return c.json({ error: 'Prompt is required' }, 400);
+    }
+    const answer = await prompt(question);
+    return c.json({ answer });
+}

package/dist/api/settings.js

@@ -0,0 +1,39 @@
+import {} from "../interfaces/settings.js";
+import { getJSON, setJSON } from "../utils/json-file.js";
+import { httpValidationErrror as httpValidationError, isEmpty } from "./utils.js";
+const defaultOpenRouterURL = "https://openrouter.ai/api/v1";
+export const defaultModel = "meta-llama/llama-3.3-70b-instruct";
+export async function api_get_settings(c) {
+    return c.json(getSettings());
+}
+export async function api_save_settings(c) {
+    const settings = await c.req.json();
+    if (settings.openRouterApiKey == undefined) {
+        httpValidationError("openRouterApiKey is required");
+    }
+    if (isEmpty(settings.openRouterURL)) {
+        settings.openRouterURL = defaultOpenRouterURL;
+    }
+    if (isEmpty(settings.defaultModel)) {
+        settings.defaultModel = defaultModel;
+    }
+    if (settings.openRouterURL == undefined) {
+        httpValidationError("openRouterURL is required");
+    }
+    if (!settings.openRouterURL.startsWith("https://")) {
+        httpValidationError("openRouterURL must start with https://");
+    }
+    // Remove trailing slash if present
+    if (settings.openRouterURL.endsWith("/")) {
+        settings.openRouterURL = settings.openRouterURL.slice(0, -1);
+    }
+    setJSON('settings', settings);
+    return c.json(getSettings());
+}
+export function getSettings() {
+    const settings = getJSON("settings", {
+        openRouterApiKey: "",
+        openRouterURL: defaultOpenRouterURL,
+    });
+    return settings;
+}

package/dist/api/tools.js

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, promises, readdirSync, writeFileSync } from "fs";
+import { extname, join } from "path";
+import { extensionLess, tarskFolder } from "./utils.js";
+import { logError, logWrite } from "../log/log.js";
+import tsBlankSpace from "ts-blank-space";
+// POST /tools to save a tool's typescript definition, convert it to javascript and validate it
+export async function api_save_tool(c) {
+    logWrite({ type: "api_save_tool", args: {} });
+    const tool = await c.req.json();
+    if (tool.name == "") {
+        tool.name = tool.title;
+    }
+    const title = tool.title;
+    const code = tool.code;
+    const name = tool.name.toLowerCase().replaceAll(" ", "_");
+    if (!title || !code || !name) {
+        return c.json({ error: "Title and code are required" }, 400);
+    }
+    // Convert typescript to javascript
+    // let answer = await prompt(
+    //   `Given the following typescript return the equivalent javascript. Do not explain just return the javascript\n${tool.code}`
+    // );
+    const answer = tsBlankSpace(tool.code ?? '', (e) => {
+        logError({ type: 'failed_ts_to_js', args: e });
+    });
+    // Get rid of the markdown code block AI adds
+    // answer = stripMarkdown(answer);
+    // Choose a filename
+    const filename = name.replace(/\s+/g, "_").toLowerCase();
+    const filePath = join(toolsJSFolder(), `${filename}.js`);
+    const srcPath = join(toolsSrcFolder(), `${filename}.ts`);
+    const metaPath = join(toolsSrcFolder(), `${filename}.json`);
+    // Save the Typescript
+    writeFileSync(srcPath, code, "utf-8");
+    writeFileSync(metaPath, JSON.stringify({ title, name }, null, 2), "utf-8");
+    // Save the Javascript
+    writeFileSync(filePath, answer, "utf-8");
+    return c.json({ message: `Tool saved successfully (${filePath})` });
+}
+// Get the tool with code
+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);
+}
+// Delete the tool with code
+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}.json`));
+    await promises.rm(join(toolsJSFolder(), `${name}.js`));
+}
+async function getTool(name) {
+    const toolsFolder = toolsSrcFolder();
+    const code = await promises.readFile(join(toolsFolder, `${name}.ts`), "utf-8");
+    const meta = await promises.readFile(join(toolsFolder, `${name}.json`), "utf-8");
+    const json = JSON.parse(meta);
+    return { code, title: json.title, name: json.name };
+}
+// Get a list of tools (code is omitted)
+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);
+}
+// Typescript files for tools
+async function toolFilenames() {
+    const toolsFolder = toolsSrcFolder();
+    const files = await promises.readdir(toolsFolder);
+    return files.filter((f) => extname(f) === ".ts").map((f) => extensionLess(f));
+}
+// Returns the compiled tools folder
+function toolsJSFolder() {
+    const folderPath = join(tarskFolder(), ".tools");
+    if (!existsSync(folderPath)) {
+        mkdirSync(folderPath, { recursive: true });
+    }
+    return folderPath;
+}
+// Javascript files for tools
+export function toolJavascriptFilenames() {
+    const files = readdirSync(toolsJSFolder());
+    return files
+        .filter((f) => extname(f) === ".js")
+        .map((f) => join(tarskFolder(), ".tools", f));
+}
+// Returns the source tools folder
+function toolsSrcFolder() {
+    const folderPath = join(tarskFolder(), "tools");
+    if (!existsSync(folderPath)) {
+        mkdirSync(folderPath, { recursive: true });
+    }
+    return folderPath;
+}

package/dist/api/utils.js

@@ -0,0 +1,17 @@
+import { HTTPException } from "hono/http-exception";
+import { extname, join } from "path";
+export function extensionLess(filename) {
+    return filename.substring(0, filename.length - extname(filename).length);
+}
+export function tarskFolder() {
+    return join(process.cwd(), "dist", ".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/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { api_prompt } from "./api/prompt.js";
+import { api_delete_tool, api_get_tool, api_get_tools, api_save_tool, } from "./api/tools.js";
+import { api_get_settings, api_save_settings } from "./api/settings.js";
+import { api_get_models } from "./api/models.js";
+const app = new Hono();
+app.use("/*", cors({
+    // `c` is a `Context` object
+    origin: (origin, c) => {
+        return (origin.startsWith("http://localhost") ||
+            origin.startsWith('https://tarsk.pages.dev')) ? origin : "x";
+    },
+}));
+// API endpoints
+app.get("/", (c) => {
+    return c.text("Tarsk Started.");
+});
+app.post("/prompt", async (c) => await api_prompt(c));
+app.post("/tools", async (c) => await api_save_tool(c));
+app.get("/tools", async (c) => await api_get_tools(c));
+app.get("/tools/:tool", async (c) => await api_get_tool(c));
+app.delete("/tools/:tool", async (c) => await api_delete_tool(c));
+app.get("/settings", async (c) => await api_get_settings(c));
+app.post("/settings", async (c) => await api_save_settings(c));
+app.get("/models", async (c) => await api_get_models(c));
+serve({
+    fetch: app.fetch,
+    port: 4021,
+}, (info) => {
+    console.log(`Tarsk is running on http://localhost:${info.port}`);
+});

package/dist/interfaces/model.js

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

package/dist/interfaces/settings.js

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

package/dist/log/log.js

@@ -0,0 +1,33 @@
+let logLevel = "debug";
+// Structured logging
+export function logWrite(l, additionalMessage) {
+    if (logLevel !== "none")
+        return;
+    l.id = id();
+    console.log(`${l.type}:${l.message} ${additionalMessage}`);
+    console.log(l, additionalMessage);
+    // TODO: send to server stringified
+    //    console.log(JSON.stringify(l));
+}
+export function logStart(l, additionalMessage) {
+    if (logLevel === "none")
+        return;
+    console.time(l.type);
+    if (additionalMessage) {
+        console.log(`Started ${l.type} ${additionalMessage}`);
+    }
+    logWrite(l);
+}
+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

@@ -0,0 +1,43 @@
+import { completion } from "./agent/agent.js";
+import { loadTools } from "./agent/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) {
+    const settings = await getSettings();
+    if (settings.openRouterApiKey == "") {
+        return "You need to set the OpenRouter API key in the settings.";
+    }
+    const options = {
+        baseUrl: settings.openRouterURL,
+        apiKey: settings.openRouterApiKey,
+    };
+    const messages = [{ role: "user", content }];
+    const model = isEmpty(settings.defaultModel)
+        ? defaultModel
+        : settings.defaultModel;
+    // Load the tools needed for the request
+    logWrite({ type: "prompt", args: content }, `The model is ${model}`);
+    const filenames = toolJavascriptFilenames();
+    logStart({ type: "load_tools", args: filenames });
+    const tools = await loadTools(filenames // eg ["../tools/books.js"]
+    );
+    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}).`;
+    }
+    return e;
+}

package/dist/test/agent-spec.js

@@ -0,0 +1,26 @@
+import { join } from "path";
+import { completion } from "../agent/agent.js";
+import { loadTools } from "../agent/tools.js";
+import { logWrite } from "../log/log.js";
+export async function prompt(content) {
+    const options = {
+        baseUrl: 'https://openrouter.ai/api/v1',
+        apiKey: ''
+    };
+    const messages = [
+        { role: 'user', content }
+    ];
+    const model = 
+    //'google/gemini-flash-1.5';
+    'meta-llama/llama-3.3-70b-instruct';
+    logWrite({ type: 'run-test', args: content });
+    // Load the tools needed for the request
+    const tools = await loadTools([join('..', '.tarsk', '.tools', 'books.js')]
+    //['../tools/books.js']
+    );
+    const request = { model, tools, messages };
+    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;
+}

package/dist/test/prompt.js

@@ -0,0 +1,5 @@
+import { prompt } from "./agent-spec.js";
+const m = await prompt(
+//'Are you capable of function/tool calls?',
+'what books were authored in 1981?');
+console.log(m);

package/dist/tools/books.js

@@ -0,0 +1,42 @@
+// Searches for books in the Project Gutenberg library based on provided search terms
+// @param @array @required searchTerms List of search terms to find books in the Gutenberg library (e.g. ['dickens', 'great'] to search for books by Dickens with 'great' in the title)
+export async function searchGutenbergBooks(searchTerms) {
+    const searchQuery = searchTerms.join(' ');
+    const url = 'https://gutendex.com/books';
+    const response = await fetch(`${url}?search=${searchQuery}`);
+    const data = await response.json();
+    return data.results.map((book) => ({
+        id: book.id,
+        title: book.title,
+        authors: book.authors,
+    }));
+}
+export const toolMap = {
+    searchGutenbergBooks
+};
+export default function tools() {
+    return booksTools;
+}
+// Automate via TS Morph?
+const booksTools = [
+    {
+        type: 'function',
+        function: {
+            name: 'searchGutenbergBooks',
+            description: 'Search for books in the Project Gutenberg library based on specified search terms',
+            parameters: {
+                type: 'object',
+                properties: {
+                    searchTerms: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        description: "List of search terms to find books in the Gutenberg library (e.g. ['dickens', 'great'] to search for books by Dickens with 'great' in the title)",
+                    },
+                },
+                required: ['searchTerms'],
+            },
+        },
+    },
+];

package/dist/utils/json-file.js

@@ -0,0 +1,19 @@
+import { join } from "path";
+import { tarskFolder } from "../api/utils.js";
+import { existsSync, 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)) {
+        writeFileSync(filename, JSON.stringify(defaultValue));
+        return defaultValue;
+    }
+    else {
+        const data = JSON.parse(decryptString(readFileSync(filename, 'utf-8')));
+        return data;
+    }
+}
+export function setJSON(name, value) {
+    const filename = join(tarskFolder(), name + '.json');
+    writeFileSync(filename, encryptString(JSON.stringify(value)));
+}

package/dist/utils/strip-markdown.js

@@ -0,0 +1,7 @@
+// Given some markdown for code remove the ``` code block lines
+export function stripMarkdown(markdown) {
+    // Remove the code block lines
+    const lines = markdown.split("\n");
+    const strippedLines = lines.filter(line => !line.startsWith("```"));
+    return strippedLines.join("\n").trim();
+}

package/dist-old/.tarsk/.tools/books.js

@@ -0,0 +1,59 @@
+// Searches for books in the Project Gutenberg library based on provided search terms
+// @param @array @required searchTerms List of search terms to find books in the Gutenberg library (e.g. ['dickens', 'great'] to search for books by Dickens with 'great' in the title)
+export async function searchGutenbergBooks(searchTerms          )                  {
+  const searchQuery = searchTerms.join(' ');
+  const url = 'https://gutendex.com/books';
+  const response = await fetch(`${url}?search=${searchQuery}`);
+  const data = await response.json();
+  return data.results.map((book     ) => ({
+    id: book.id,
+    title: book.title,
+    authors: book.authors,
+  }));
+}
+
+export const toolMap = {
+  searchGutenbergBooks
+}
+
+export default function tools() {
+  return booksTools;
+}
+
+// Automate via TS Morph?
+const booksTools = [
+  {
+    type: 'function',
+    function: {
+      name: 'searchGutenbergBooks',
+      description:
+        'Search for books in the Project Gutenberg library based on specified search terms',
+      parameters: {
+        type: 'object',
+        properties: {
+          searchTerms: { // Must match argument name in function
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            description:
+              "List of search terms to find books in the Gutenberg library (e.g. ['dickens', 'great'] to search for books by Dickens with 'great' in the title)",
+          },
+        },
+        required: ['searchTerms'],
+      },
+    },
+  },
+];
+
+;               
+             
+                
+                    
+ 
+
+;                 
+                      
+                      
+               
+ 

package/dist-old/.tarsk/.tools/dust.js

@@ -0,0 +1,82 @@
+export async function searchBurns(searchTerms          )                  {
+  const searchQuery = searchTerms.join(' ');
+  const url = 'https://api.dust.events/data/festivals.json';
+  const response = await fetch(`${url}`);
+  const data = await response.json();
+  data = data.filter((b) => b.active);
+  return data.map((burn     ) => ({
+    name: burn.name,
+    title: burn.title,
+    year: burn.year,
+    startDate: burn.start,
+    endDate: burn.end,
+    lat: burn.lat,
+    long: burn.long,
+    timeZone: burn.timeZone,
+    region: burn.region,
+    website: burn.website
+  }));
+}
+
+export const toolMap = {
+  searchBurns
+}
+
+export default function tools() {
+  return burnTools;
+}
+
+const burnTools = [
+  {
+    type: 'function',
+    function: {
+      name: 'searchBurns',
+      description:
+        "Search for regional burning man events based on specified search terms",
+      parameters: {
+        type: 'object',
+        properties: {
+          searchTerms: { // Must match argument name in function
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            description:
+              "List of search terms (e.g. ['snrg', 'soak'] to search for regional burns with 'snrg' or 'soak' in the title",
+          },
+        },
+        required: ['searchTerms'],
+      },
+    },
+  },
+];
+
+;                      
+              
+               
+              
+                 
+            
+             
+               
+             
+          
+           
+                   
+                  
+                      
+                        
+                 
+                    
+                
+                 
+                       
+                                 
+                                  
+                             
+                            
+                             
+             
+                     
+ 
+

package/dist-old/.tarsk/settings.json

@@ -0,0 +1 @@
+zO3DHSWwKmpUWImXKWcplw==:3JB/NEXlkvGBxoHDcGPz7uWbAALPiq2+EiRLIC3ejJy0CxaKVV2Aquaw807PwN0z0LLBOvzD56a9atm9cA3yvVhRuwqqIC3Tx4Wy/8dQWixomj9rjKHbnDp7uJ2EZt853AYUuY9ZpgDgM61X+AwcVLw8Xs4meHzV7yZxM57oOER4Y/hLu7ywMV+wEucZd9PL/VBW4/6p/6tFmA5C7DD3CNgIEIyrqyJMzn8L/kQiSs+ZfGa3iXjdQtyPuNBY0fSA4o6lWJnbQ6IkKifL6DDx2A==

package/dist-old/.tarsk/tools/books.json

@@ -0,0 +1,4 @@
+{
+  "title": "Books",
+  "name": "books"
+}

package/dist-old/.tarsk/tools/books.ts

@@ -0,0 +1,59 @@
+// Searches for books in the Project Gutenberg library based on provided search terms
+// @param @array @required searchTerms List of search terms to find books in the Gutenberg library (e.g. ['dickens', 'great'] to search for books by Dickens with 'great' in the title)
+export async function searchGutenbergBooks(searchTerms: string[]): Promise<Book[]> {
+  const searchQuery = searchTerms.join(' ');
+  const url = 'https://gutendex.com/books';
+  const response = await fetch(`${url}?search=${searchQuery}`);
+  const data = await response.json();
+  return data.results.map((book: any) => ({
+    id: book.id,
+    title: book.title,
+    authors: book.authors,
+  }));
+}
+
+export const toolMap = {
+  searchGutenbergBooks
+}
+
+export default function tools() {
+  return booksTools;
+}
+
+// Automate via TS Morph?
+const booksTools = [
+  {
+    type: 'function',
+    function: {
+      name: 'searchGutenbergBooks',
+      description:
+        'Search for books in the Project Gutenberg library based on specified search terms',
+      parameters: {
+        type: 'object',
+        properties: {
+          searchTerms: { // Must match argument name in function
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            description:
+              "List of search terms to find books in the Gutenberg library (e.g. ['dickens', 'great'] to search for books by Dickens with 'great' in the title)",
+          },
+        },
+        required: ['searchTerms'],
+      },
+    },
+  },
+];
+
+interface Book {
+  id: string;
+  title: string;
+  authors: Person[];
+}
+
+interface Person {
+  birth_year?: number;
+  death_year?: number;
+  name: string;
+}

package/dist-old/.tarsk/tools/dust.json

@@ -0,0 +1,4 @@
+{
+  "title": "Dust",
+  "name": "dust"
+}

package/dist-old/.tarsk/tools/dust.ts

@@ -0,0 +1,82 @@
+export async function searchBurns(searchTerms: string[]): Promise<Burn[]> {
+  const searchQuery = searchTerms.join(' ');
+  const url = 'https://api.dust.events/data/festivals.json';
+  const response = await fetch(`${url}`);
+  const data = await response.json();
+  data = data.filter((b) => b.active);
+  return data.map((burn: any) => ({
+    name: burn.name,
+    title: burn.title,
+    year: burn.year,
+    startDate: burn.start,
+    endDate: burn.end,
+    lat: burn.lat,
+    long: burn.long,
+    timeZone: burn.timeZone,
+    region: burn.region,
+    website: burn.website
+  }));
+}
+
+export const toolMap = {
+  searchBurns
+}
+
+export default function tools() {
+  return burnTools;
+}
+
+const burnTools = [
+  {
+    type: 'function',
+    function: {
+      name: 'searchBurns',
+      description:
+        "Search for regional burning man events based on specified search terms",
+      parameters: {
+        type: 'object',
+        properties: {
+          searchTerms: { // Must match argument name in function
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            description:
+              "List of search terms (e.g. ['snrg', 'soak'] to search for regional burns with 'snrg' or 'soak' in the title",
+          },
+        },
+        required: ['searchTerms'],
+      },
+    },
+  },
+];
+
+export interface Burn {
+  name: string
+  title: string
+  year: string
+  active: boolean
+  id: string
+  uid: number
+  start: string
+  end: string
+  lat: any
+  long: any
+  imageUrl?: string
+  timeZone: string
+  mapDirection: number
+  mastodonHandle: string
+  rssFeed: string
+  inboxEmail: string
+  region: string
+  website: string
+  unknownDates: boolean
+  volunteeripateSubdomain: string
+  volunteeripateIdentifier: string
+  pin_size_multiplier: number
+  camp_registration: boolean
+  event_registration: boolean
+  pin: string
+  directions?: string
+}
+

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "tarsk",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "npm run build && npm link && tarsk",
+    "restart": "npm unlink tarsk && rm -rf dist && npm run build && npm link && tarsk",
+    "dev": "tsx watch src/index.ts"
+  },
+  "bin": {
+    "tarsk": "dist/index.js"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.14.1",
+    "hono": "^4.7.7",
+    "ts-blank-space": "^0.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "tsx": "^4.7.1"
+  },
+  "version": "0.0.1"
+}