tune-basic-toolset 0.1.6 → 0.1.8

package/README.md

@@ -17,10 +17,12 @@ Basic toolset for [Tune](https://github.com/iovdin/tune).
   - [jina_r](#jina_r) fetch webpage content
   - [turn](#turn) turn based agent
   - [list](#list) keep list of tasks todo (loops for LLM)
+  - [sqlite](#sqlite) execute sqlite queries 
   - [py](#py) run python code
   - [js](#js) run javascript code
   - [message](#message) talk to another chat/agent
 - [Processors](#processors)
+  - [proc](#proc) converts tool to processor
   - [shp](#shp) include shell command output
   - [init](#init) set initial value
   - [json_format](#json_format) make LLM respond with JSON
@@ -284,6 +286,45 @@ tool_result:
 list updated
 ```
 
+### `sqlite`
+execut sqlite queries with sqlite shell
+
+```chat
+user:
+@sqlite
+
+create a simple todo table in db.sqlite and fill it with fake data
+assistant:
+
+tool_call: sqlite {"filename":"db.sqlite"}
+CREATE TABLE todo (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task TEXT NOT NULL,
+  status TEXT CHECK(status IN ('pending', 'completed')) NOT NULL DEFAULT 'pending',
+  due_date DATE
+);
+
+INSERT INTO todo (task, status, due_date) VALUES
+('Buy groceries', 'pending', '2024-05-01'),
+('Finish project report', 'pending', '2024-05-03'),
+('Book flight tickets', 'completed', '2024-04-25'),
+('Call plumber', 'pending', '2024-04-30'),
+('Schedule meeting with team', 'completed', '2024-04-20');
+tool_result:
+
+user:
+check pending tasks
+
+assistant:
+
+tool_call: sqlite {"filename":"db.sqlite","format":"json"}
+SELECT * FROM todo WHERE status = 'pending';
+tool_result:
+[{"id":1,"task":"Buy groceries","status":"pending","due_date":"2024-05-01"},
+{"id":2,"task":"Finish project report","status":"pending","due_date":"2024-05-03"},
+{"id":4,"task":"Call plumber","status":"pending","due_date":"2024-04-30"}]
+```
+
 
 ### `py`
 execute python code
@@ -370,6 +411,20 @@ Because it had a root canal!
 ## Processors
 [Processors](https://iovdin.github.io/tune/template-language/processors) is a way to modify variable or insert new ones into chat.
 
+### `proc`
+converts any tool to a processor
+``` chat
+system:
+include project file list to system prompt
+@{| proc sh git ls-files }
+
+execute script with sqlite on db `db.sqlite` and insert result
+@{ script.sql | proc sqlite filename=db.sqlite }
+
+execut python script text="384 * 123" and insert back result
+@{| proc py 384 * 123  }
+```
+
 ### `shp`
 Insert shell command output
 ```chat
@@ -623,3 +678,4 @@ tool_call: todo
 tool_result:
 list updated
 ```
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tune-basic-toolset",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Basic toolset for tune",
   "main": "src/index.js",
   "files": [

package/src/patch.tool.js

@@ -17,7 +17,7 @@ module.exports = async function patch({ text, filename }, ctx) {
   }
 
   if (patches.length === 0) {
-    throw new Error("No valid patch segments found");
+    return "No valid patch segments found";
   }
 
   let fileContent = await ctx.read(filename);
@@ -35,4 +35,4 @@ module.exports = async function patch({ text, filename }, ctx) {
 
   await ctx.write(filename, fileContent);
   return "patched";
-};
+};

package/src/proc.proc.js

@@ -0,0 +1,139 @@
+
+module.exports = async function proc(node, args, ctx) {
+  /*
+  @{| proc sh }
+  @{ script.sh | proc sh }
+  @{| proc sqlite SELECT * FROM table }
+  @{| proc sqlite filename=db.sqlite text="SELECT * FROM table" }
+  */
+
+  const [ toolName, params ] = parseCommandLine(args)
+  if (node && !params.text) {
+    params.text = await node.read()
+  }
+
+  const tool = await ctx.resolve(toolName, { "type": "tool" })
+
+  console.log(params)
+
+  if (!tool || tool.type !== "tool") {
+    throw Error(`tool '${toolName}' not found`)
+  }
+
+  return {
+    ...node,
+    type: "text",
+    read: async() => tool.exec.call(ctx, params, ctx)
+  }
+}
+
+// Examples:
+// parseCommandLine('command hello world bla bla')
+// -> ["command", { text: "hello world bla bla" }]
+//
+// parseCommandLine('cmd hello=world num=8 text="bla \\"bla"')
+// -> ["cmd", { hello: "world", num: 8, text: 'bla "bla' }]
+//
+// parseCommandLine('cmd')
+// -> ["cmd", {}]
+
+function parseCommandLine(input) {
+  const s = String(input);
+  let i = 0, len = s.length;
+
+  function skipWS() { while (i < len && /\s/.test(s[i])) i++; }
+
+  // 1) Parse leading alphanumeric command
+  skipWS();
+  const cmdStart = i;
+  while (i < len && /[A-Za-z0-9]/.test(s[i])) i++;
+  const command = s.slice(cmdStart, i);
+  if (!command) return [null, {}];
+
+  // 2) Parse the remainder as args
+  skipWS();
+  const r = s.slice(i);
+  if (!r.trim()) return [command, {}];
+
+  function parseArgs(str) {
+    if (!/^\s*[A-Za-z0-9]+=/.test(str)) {
+      return { text: str.trim() };
+    }
+
+    let j = 0;
+    const L = str.length;
+    const out = {};
+
+    function skipW() { while (j < L && /\s/.test(str[j])) j++; }
+
+    function parseKey() {
+      const start = j;
+      while (j < L && str[j] !== '=' && !/\s/.test(str[j])) j++;
+      return str.slice(start, j);
+    }
+
+    function parseQuotedValue(q) {
+      j++; // skip opening quote
+      let val = '';
+      while (j < L) {
+        const ch = str[j++];
+        if (ch === '\\') {
+          if (j >= L) break;
+          const esc = str[j++];
+          if (esc === 'n') val += '\n';
+          else if (esc === 't') val += '\t';
+          else if (esc === 'r') val += '\r';
+          else val += esc; // includes \" \\ \'
+        } else if (ch === q) {
+          return val;
+        } else {
+          val += ch;
+        }
+      }
+      return val; // best-effort if unclosed
+    }
+
+    function parseUnquotedValue() {
+      const start = j;
+      while (j < L && !/\s/.test(str[j])) j++;
+      return str.slice(start, j);
+    }
+
+    function coerce(v) {
+      if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
+      const low = v.toLowerCase();
+      if (low === 'true') return true;
+      if (low === 'false') return false;
+      if (low === 'null') return null;
+      return v;
+    }
+
+    while (j < L) {
+      skipW();
+      if (j >= L) break;
+
+      const key = parseKey();
+      if (!key) return { text: str.trim() };
+
+      skipW();
+      if (j < L && str[j] === '=') {
+        j++; // skip '='
+        skipW();
+        let valueStr = '';
+        if (j < L && (str[j] === '"' || str[j] === "'")) {
+          valueStr = parseQuotedValue(str[j]);
+        } else {
+          valueStr = parseUnquotedValue();
+        }
+        out[key] = coerce(valueStr);
+      } else {
+        // If a non key=value token appears, treat the whole remainder as text
+        return { text: str.trim() };
+      }
+    }
+
+    return out;
+  }
+
+  return [command, parseArgs(r)];
+}

package/src/shp.proc.js

@@ -12,7 +12,7 @@ const shp = async (node, args, ctx) => ({
     let result;
     try {
       if (input !== null) {
-        const res = spawnSync(args.trim(), {
+        const res = spawnSync(args.trim() || "sh", {
           input,
           encoding: 'utf8',
           shell: true
@@ -28,4 +28,4 @@ const shp = async (node, args, ctx) => ({
   }
 });
 
-module.exports = shp;
+module.exports = shp;

package/src/sqlite.schema.json

@@ -0,0 +1,23 @@
+{
+  "description": "Execute SQLite multiple queries on a given database file",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "filename": {
+        "type": "string",
+        "description": "Path to the SQLite database file"
+      },
+      "text": {
+        "type": "string",
+        "description": "SQL queries to execute, 1 per line"
+      },
+      "format": {
+        "type": "string",
+        "description": "Output format for the query result",
+        "enum": ["line", "list", "csv", "html", "json", "table", "tabs"],
+        "default": "line"
+      }
+    },
+    "required": ["filename", "text"]
+  }
+}

package/src/sqlite.tool.js

@@ -0,0 +1,19 @@
+const cp = require('node:child_process')
+
+module.exports = async function sqlite({ filename, text, format = "table"}, ctx)  {
+  let result = ""
+  try {
+    result = cp.execSync(`sqlite3 -${format} ${filename}`, { encoding: "utf8", input: text })
+  } catch (e) {
+    if (e.stderr) {
+      result += e.stderr
+    } 
+    if (e.stdout) {
+      result += e.stdout
+    }
+    if (!result) {
+      result = e.stack
+    }
+  }
+  return (result || "").replaceAll("@", "\\@");
+}