tune-basic-toolset 0.1.0

package/src/js.tool.js

@@ -0,0 +1,60 @@
+const { parseScript } = require('esprima');
+const { generate } = require('escodegen');
+const { spawnSync } = require('child_process');
+const { writeFileSync, unlinkSync }  = require('fs');
+const { randomBytes } = require('crypto');
+
+module.exports = async function execute({ text, inputType }, ctx) {
+  // Parse the code into an Abstract Syntax Tree (AST)
+  const ast = parseScript(text, { range: true });
+
+  if (ast.body.length === 0) {
+    return null;
+  }
+
+  const lastNode = ast.body[ast.body.length - 1];
+  let modified = false;
+
+  // If the last statement is an expression, replace it with an assignment
+  if (lastNode.type === 'ExpressionStatement') {
+    const assignExpression = {
+      type: 'ExpressionStatement',
+      expression: {
+        type: 'AssignmentExpression',
+        operator: '=',
+        left: {
+          type: 'Identifier',
+          name: 'myVariable'
+        },
+        right: lastNode.expression
+      }
+    };
+    ast.body[ast.body.length - 1] = assignExpression;
+    modified = true;
+  }
+
+  const rand = randomBytes(50).toString('hex').substring(0, 10);
+  const filename = (inputType === "module") ? `tune${rand}.mjs`:`tune${rand}.js`;
+
+  let modifiedCode = generate(ast);
+  if (modified) {
+    if (inputType === "module") {
+      modifiedCode = `${modifiedCode}\nimport util from 'util';\nconsole.log(util.inspect(myVariable)) `;
+    } else  {
+      modifiedCode = `${modifiedCode}\nconsole.log(require("util").inspect(myVariable))`;
+    }
+  }
+  writeFileSync(filename, modifiedCode);
+
+  try {
+    const res = spawnSync("node", [filename], 
+      { 
+        encoding: "utf8",
+        input: modifiedCode, 
+      });
+
+    return (res.stderr + res.stdout).trim().replace(/@/g, "\\@");
+  } finally {
+    unlinkSync(filename);
+  }
+};

package/src/json_format.proc.js

@@ -0,0 +1,22 @@
+const path = require('path');
+
+module.exports = async function json_format(node, args, ctx) {
+  if (!node) {
+    return;
+  }
+  let response_format = { "type": "json_object" };
+  if (args.trim()) {
+
+    let schema = await ctx.resolve(args.trim());
+    if (!schema) throw Error(`schema file not found ${args.trim()}`);
+    schema = await schema.read();
+    response_format = { 
+      "type": "json_schema", 
+      "json_schema": JSON.parse(schema),
+    };
+  }
+  return {
+    ...node,
+    exec: async (payload, ctx) => node.exec({ ...payload, response_format }, ctx)
+  };
+};

package/src/linenum.proc.js

@@ -0,0 +1,21 @@
+/*
+  *  { type: "text" | "image" | "llm" | "tool" | "processor" }
+  *  name
+  *  read (afn )
+  */
+module.exports = async function(node, args) {
+  if (! node) {
+    return node
+  }
+  const res = Object.assign({}, node);
+  res.read = async function(args) {
+    let contents = await node.read(args);
+    contents = contents.split("\n");
+    const pad = `${contents.length}`.length;
+    return contents.map((item, index) => {
+      const lineNum = `${index + 1}`.padEnd(pad + 1, " ") + "|";
+      return `${lineNum} ${item}`
+    }).join("\n")
+  }
+  return res
+}

package/src/list.schema.json

@@ -0,0 +1,19 @@
+{
+  "description": "Manages todo lists",
+  "strict": true,
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "lines in format 'status - item', they'll be used to update list or to insert to the list, to delete item change its status to deleted or cancelled\nThe lines should contain only those items that needs to be changed - inserted/updated/deleted"
+      },
+      "filename": {
+        "type": "string",
+        "description": "location of the todo list file"
+      }
+    },
+    "required": ["text", "filename"],
+    "additionalProperties": false
+  }
+}

package/src/list.tool.js

@@ -0,0 +1,20 @@
+function parse(text) {
+  const lines = text.split("\n").map(item => item.trim()).filter(item => item);
+  return lines.reduce((memo, line) => { 
+    const idx = line.indexOf("-");
+    if (idx === -1) return memo;
+    const status = line.slice(0, idx).trim();
+    const task = line.slice(idx+1).trim();
+    memo[task] = status;
+    return memo;
+  }, 
+    {});
+}
+module.exports = async function list({text, filename}, ctx) {
+  let todo = parse(await ctx.read(filename) || "");
+  const changes = parse(text);
+  todo = { ...todo, ...changes };
+  todo = Object.keys(todo).map(key => `${todo[key]} - ${key}`).join("\n");
+  await ctx.write(filename, todo);
+  return "list updated";
+};

package/src/log.proc.js

@@ -0,0 +1,15 @@
+const fs = require("fs")
+const path = require("path")
+
+module.exports = async (node, args, ctx)  => ({
+  ...node,
+  exec: async function(payload, ctx) {
+    const res = await node.exec(payload, ctx)
+    const body = JSON.parse(res.body)
+    payload = {...res, body};
+    const filename = args.trim() || "log.json"
+    const content =  path.extname(filename) == ".chat" ? ctx.msg2text(payload.body.messages, true) : JSON.stringify(payload, null, "  ") 
+    fs.writeFileSync(filename, content);
+    return res
+  }
+})

package/src/message.schema.json

@@ -0,0 +1,21 @@
+{
+  "description": "this tool sends a message to another ai chat as 'user' role, result of the tool is an 'assistant' reply",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "filename": {
+        "type": "string",
+        "description": "File name to read/write chat history, should have .chat extension"
+      },
+      "system": {
+        "type": "string",
+        "description": "Filename that contains system prompt, required once at the beginning of simulation"
+      },
+      "text": {
+        "type": "string",
+        "description": "User message to send"
+      }
+    },
+    "required": ["filename", "text"]
+  }
+}

package/src/message.tool.js

@@ -0,0 +1,14 @@
+module.exports = async function message({ filename, system, text, stop }, ctx) {
+  let chat = await ctx.read(filename);
+  if (!chat && system) {
+    chat = `system: @@${system}`
+  }
+  chat = `${chat}\nuser:\n${text}`
+  const messages = await ctx.text2run(chat, {stop: "assistant" })
+  chat = `${chat}\n${ctx.msg2text(messages, true)}`
+  await ctx.write(filename, chat)
+  if (messages.length) {
+    return messages[messages.length - 1].content
+  }
+  return ""
+}

package/src/mock.proc.js

@@ -0,0 +1,35 @@
+module.exports = async function mock(node, args, ctx) {
+  const re = /(?<name>\w+)\s*=/
+  let lastName;
+  let m;
+  let text = args;
+  const vars = {};
+  while ((m = re.exec(text)) !== null) {
+    const { name } = m.groups
+
+    if (lastName) {
+      vars[lastName] = text.slice(0, m.index).trim()
+    }
+    text = text.slice(m.index + m[0].length)
+    lastName = name
+  }
+  if (lastName) {
+    vars[lastName] = text.trim()
+  }
+  ctx.use((name, ctx, args)=> {
+    if (!vars.hasOwnProperty(name)) {
+      return 
+    }
+    return {
+      ...node,
+      type: "text",
+      name,
+      read: async () => vars[name]
+    }
+  })
+  return { 
+    ...node,
+    type: "text", 
+    read: async() => ""
+  }
+}

package/src/osa.schema.json

@@ -0,0 +1,13 @@
+{
+  "description": "Execute osascript command and return output",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "The osascript command to execute"
+      }
+    },
+    "required": ["text"]
+  }
+}

package/src/osa.tool.js

@@ -0,0 +1,12 @@
+const { execSync } = require('child_process');
+const util = require('util');
+
+module.exports = async function osa({ text }) {
+  let result = "";
+  try {
+    result = execSync("osascript -", { input: text, encoding: "utf8" });
+  } catch (e) {
+    result = e.stderr + e.stdout;
+  }
+  return (result || "").replaceAll("@", "\\@");
+};

package/src/patch.schema.json

@@ -0,0 +1,17 @@
+{
+  "description": "Apply patches to a specified file based on the given text",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "The text containing patches to apply, formated:\n```\n<<<<<<< ORIGINAL\nold code\n=======\nnew code\n>>>>>>> UPDATED\n```"
+      },
+      "filename": {
+        "type": "string",
+        "description": "The path to the file that needs to be patched."
+      }
+    },
+    "required": ["text", "filename"]
+  }
+}

package/src/patch.tool.js

@@ -0,0 +1,38 @@
+const fs = require('fs').promises;
+
+// Patch tool to apply custom diffs marked with <<<<<<< ORIGINAL and >>>>>>> UPDATED
+// Handles patches with context and applies only the segments between markers.
+
+module.exports = async function patch({ text, filename }, ctx) {
+  // Regex to match each patch block
+  const patchRegex = /<<<<<<< ORIGINAL[^\n]*\n([\s\S]*?)=======\n([\s\S]*?)>>>>>>> UPDATED[^\n]*(?:\n|$)/g;
+  const patches = [];
+  let match;
+
+  // Extract all old/new segments
+  while ((match = patchRegex.exec(text)) !== null) {
+    const oldPart = match[1].replace(/^\n+|\n+$/g, "");
+    const newPart = match[2].replace(/^\n+|\n+$/g, "");
+    patches.push({ oldPart, newPart });
+  }
+
+  if (patches.length === 0) {
+    throw new Error("No valid patch segments found");
+  }
+
+  let fileContent = await ctx.read(filename);
+
+  for (const { oldPart, newPart } of patches) {
+    // Escape regex special chars in oldPart, then allow flexible whitespace
+    const escaped = oldPart
+      .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+      .replace(/\s+/g, "\\s+");
+    const oldRegex = new RegExp(escaped, "g");
+
+    // Perform replacement using a function to avoid replacement string ambiguities
+    fileContent = fileContent.replace(oldRegex, () => newPart);
+  }
+
+  await ctx.write(filename, fileContent);
+  return "patched";
+};

package/src/prop.proc.js

@@ -0,0 +1,34 @@
+function parseVal(value) {
+  try {
+    return JSON.parse(value);
+  } catch (e) { }
+  return value;
+}
+module.exports = async function prop(node, args, ctx) {
+  if (!node || node.type !== 'llm') {
+    return node;
+  }
+
+  const re = /(?<name>\w+)\s*=/;
+  let lastName;
+  let m;
+  let text = args;
+  const vars = {};
+  while ((m = re.exec(text)) !== null) {
+    const { name } = m.groups;
+
+    if (lastName) {
+      vars[lastName] = parseVal(text.slice(0, m.index).trim());
+    }
+    text = text.slice(m.index + m[0].length);
+    lastName = name;
+  }
+
+  if (lastName) {
+    vars[lastName] = parseVal(text.trim());
+  }
+  return {
+    ...node,
+    exec: async (payload, ctx) => node.exec({ ...payload, ...vars }, ctx)
+  };
+};

package/src/py.schema.json

@@ -0,0 +1,17 @@
+ {
+  "description": "Execute Python code using a Node.js child process",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "The Python code to execute"
+      },
+      "filename": {
+        "type": "string",
+        "description": "filename to save script to"
+      }
+    },
+    "required": ["text"]
+  }
+}

package/src/py.tool.py

@@ -0,0 +1,22 @@
+import ast
+import sys
+
+def main(params):
+    if 'filename' in params:
+        with open(params['filename'], 'w') as file:
+            file.write(params['text'])
+
+    parsed = ast.parse(params['text'])
+    last_stmt = parsed.body[-1]
+    if isinstance(last_stmt, ast.Expr):
+        parsed.body[-1] = ast.Assign(
+                targets=[ast.Name(id='myvariable', ctx=ast.Store())],
+                value=last_stmt.value)
+
+    ast.fix_missing_locations(parsed)
+    compiled = compile(parsed, filename="cell.py", mode="exec")
+    namespace = {}
+    exec(compiled, namespace)
+
+    return namespace.get('myvariable', None) 
+    

package/src/resolve.proc.js

@@ -0,0 +1,10 @@
+module.exports = async function resolve(node, args, ctx) {
+  if (!node) {
+    return
+  }
+  if (node.type !== "text") {
+    throw Error(`can resolve only text nodes, got ${node.type}`)
+  }
+  const filename = await node.read()
+  return ctx.resolve(filename.trim())
+}

package/src/rf.schema.json

@@ -0,0 +1,17 @@
+{
+  "description": "Read the contents of a specified file",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "filename": {
+        "type": "string",
+        "description": "The name of the file to read"
+      },
+      "linenum": {
+        "type": "boolean",
+        "description": "prepend every line with linenumber"
+      }
+    },
+    "required": ["filename"]
+  }
+}

package/src/rf.tool.js

@@ -0,0 +1,20 @@
+const { relative, dirname } = require('path');
+
+module.exports = async function readFile({ filename, linenum }, ctx) {
+  const resolved = await ctx.resolve(filename);
+  if (!resolved) {
+    return "File not found";
+  }
+  const relFile = relative(process.cwd(), filename);
+  const pathArr = [ relFile ];
+  if (resolved.type !== 'text') {
+    pathArr.push('text');
+  }
+  if (linenum) {
+    pathArr.push('linenum');
+  }
+  if (pathArr.length > 1) {
+    return`@{ ${pathArr.join(" | ")} }`;
+  }
+  return `@${relFile}`;
+};

package/src/sh.schema.json

@@ -0,0 +1,13 @@
+  {
+  "description": "Execute a shell command",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "The shell command to execute"
+      }
+    },
+    "required": ["text"]
+  }
+}

package/src/sh.tool.js

@@ -0,0 +1,12 @@
+const { execSync } = require('child_process');
+const util = require('util');
+
+module.exports = async function sh({ text }) {
+  let result = "";
+  try {
+    result =  execSync(text, { encoding: "utf8" });
+  } catch (e) {
+    result = e.stderr + e.stdout;
+  }
+  return (result || "").replaceAll("@", "\\@");
+};

package/src/shp.proc.js

@@ -0,0 +1,31 @@
+const { execSync, spawnSync } = require('child_process');
+
+const shp = async (node, args, ctx) => ({
+  type: 'text',
+  read: async () => {
+    let input = null;
+
+    if (node && node.type === 'text') {
+      input = await node.read();
+    }
+
+    let result;
+    try {
+      if (input !== null) {
+        const res = spawnSync(args.trim(), {
+          input,
+          encoding: 'utf8',
+          shell: true
+        });
+        result = (res.stdout || '') + (res.stderr || '');
+      } else {
+        result = execSync(args.trim(), { encoding: 'utf8' });
+      }
+    } catch (e) {
+      result = e.stderr + e.stdout;
+    }
+    return result.replaceAll('@', '\\@');
+  }
+});
+
+module.exports = shp;

package/src/slice.proc.js

@@ -0,0 +1,55 @@
+module.exports = async function slice(node, args, context) {
+  if (!node || node.type !== 'text') {
+    return node;
+  }
+
+  const parts = args ? args.trim().split(/\s+/) : [];
+  let start, end;
+
+  const parseIdx = (str) => {
+    const n = parseInt(str, 10);
+    if (isNaN(n)) return undefined;
+    return n;
+  };
+
+  if (parts.length >= 1) start = parseIdx(parts[0]);
+  if (parts.length >= 2) end = parseIdx(parts[1]);
+
+  const newNode = Object.assign({}, node);
+
+  newNode.read = async () => {
+    const text = await node.read();
+    const lines = text.split(/\r?\n/);
+    const N = lines.length;
+
+    // Convert 1-based to 0-based, handle negative indices
+    let s = start;
+    let e = end;
+
+    if (s === undefined) {
+      s = 1;  // default to line 1
+    }
+    s = s < 0 ? N + s : s - 1;  // negative or positive 1-based 
+    if (s < 0) s = 0;
+    if (s > N) s = N;
+
+    if (e !== undefined) {
+      e = e < 0 ? N + e : e;  // negative or positive 1-based inclusive
+    }
+    // Since Array.slice end index is exclusive and ours is inclusive, add 0 if undefined, +0 else +0
+    // But since end is inclusive for user, exclusive for slice, +1
+    if (e !== undefined) {
+      e = e < 0 ? Math.max(0, e + 1) : e;  // ensure inclusive end
+    }
+
+    // Convert to slice compatible indices
+    const result = lines.slice(
+      s,
+      e !== undefined ? e : undefined
+    );
+
+    return result.join('\n');
+  };
+
+  return newNode;
+};

package/src/tail.proc.js

@@ -0,0 +1,35 @@
+module.exports = async function tail(node, args, context) {
+  if (!node || (node.type !== 'text' && node.type !== 'llm')) {
+    return node;
+  }
+
+  const n = parseInt(args, 10);
+  const count = (isNaN(n) || n <= 0) ? 20 : n;
+
+
+  if (node.type === 'text') {
+    return {
+      ...node,
+      read: async () => {
+        const text = await node.read();
+        return text.split(/\r?\n/).slice(-count -1).join('\n');
+      }
+    }
+  }
+
+  // llm 
+  return {
+    ...node,
+    exec: async (payload, ctx) => {
+      let startIndex = Math.max(0, payload.messages.length - count)
+      startIndex = payload.messages.findIndex((msg, index) => (index >= startIndex) && (msg.role === 'user' || msg.role ==='assistant'))
+      const messages = payload.messages.filter(
+        (message, index) => (message.role === "system") || (index >= startIndex))
+    
+      return node.exec({
+        ...payload,
+        messages
+      }, ctx)
+    }
+  }
+};

package/src/text.proc.js

@@ -0,0 +1,11 @@
+module.exports = async function(node, args, ctx) {
+  if (! node) {
+    return node
+  }
+  return {
+    ...node,
+    type: "text",
+    read : async () => ctx.read(node.name)
+  }
+
+}

package/src/turn.schema.json

@@ -0,0 +1,17 @@
+{
+  "description": "Switch roles/agents",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "role": {
+        "type": "string",
+        "description": "The name of the role/agent to switch to"
+      },
+      "filename": {
+        "type": "string",
+        "description": "save the role name to filename that keeps the current role"
+      }
+    },
+    "required": ["name", "filename"]
+  }
+}

package/src/turn.tool.js

@@ -0,0 +1,8 @@
+const fs = require("fs");
+
+module.exports = async function turn({ role, filename }, ctx) {
+  if (filename) {
+    await ctx.write(filename, `@@${role}`);
+  }
+  return `now it is turn of ${role} to reply`;
+};

package/src/wf.schema.json

@@ -0,0 +1,17 @@
+ {
+  "description": "Asynchronous function to write content to a file",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "filename": {
+        "type": "string",
+        "description": "The name of the file to write"
+      },
+      "text": {
+        "type": "string",
+        "description": "The content to write to the file"
+      }
+    },
+    "required": ["filename", "text"]
+  }
+}

package/src/wf.tool.js

@@ -0,0 +1,7 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+module.exports = async function writeFile({ filename, text }, ctx) {
+  await ctx.write(filename, text)
+  return `written`;
+};