runline 0.4.0 → 0.5.1

package/dist/core/engine.js

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { getQuickJS, shouldInterruptAfterDeadline, } from "quickjs-emscripten";
 import { applyEnvOverrides, updateConnectionConfig } from "../config/loader.js";
 export class ExecutionEngine {
@@ -215,6 +216,14 @@ function formatError(cause) {
     }
     return String(cause);
 }
+// MiniSearch UMD bundle, vendored at the package root and inlined into the
+// sandbox source. UMD attaches `MiniSearch` to globalThis in a non-CJS /
+// non-AMD env (QuickJS), so pasting the file is enough.
+//
+// `../../vendor/...` resolves identically from src/core/engine.ts (dev) and
+// dist/core/engine.js (published) because tsc preserves the `core/` subdir.
+// See vendor/README.md for the upgrade procedure.
+const __minisearchSource = readFileSync(new URL("../../vendor/minisearch.umd.js", import.meta.url), "utf8");
 function buildHelpData(plugins) {
     const data = {};
     for (const p of plugins) {
@@ -223,7 +232,11 @@ function buildHelpData(plugins) {
             description: a.description,
             inputs: Object.fromEntries(Object.entries(a.inputSchema ?? {}).map(([k, v]) => [
                 k,
-                `${v.type}${v.required ? " (required)" : ""}${v.description ? " — " + v.description : ""}`,
+                {
+                    type: v.type,
+                    required: !!v.required,
+                    description: v.description,
+                },
             ])),
         }));
     }
@@ -247,15 +260,14 @@ const __fmt = (v) => {
   try { return JSON.stringify(v); } catch { return String(v); }
 };
 
+// Inlined MiniSearch UMD — attaches MiniSearch to globalThis inside the sandbox.
+${__minisearchSource}
+
 const __help = ${JSON.stringify(helpData)};
 
 const __makeProxy = (path = []) => new Proxy(() => undefined, {
   get(_t, prop) {
     if (prop === 'then' || typeof prop === 'symbol') return undefined;
-    if (prop === 'help') {
-      const pluginName = path[0];
-      return () => pluginName && __help[pluginName] ? __help[pluginName] : __help;
-    }
     return __makeProxy([...path, String(prop)]);
   },
   apply(_t, _this, args) {
@@ -265,8 +277,126 @@ const __makeProxy = (path = []) => new Proxy(() => undefined, {
       .then((raw) => raw === undefined ? undefined : JSON.parse(raw));
   },
 });
-const actions = __makeProxy();
-const help = () => __help;
+
+// Flat index of every "plugin.action" path → { plugin, entry }
+const __index = (() => {
+  const out = Object.create(null);
+  for (const plugin of Object.keys(__help)) {
+    for (const e of __help[plugin]) {
+      out[plugin + '.' + e.action] = { plugin, entry: e };
+    }
+  }
+  return out;
+})();
+
+const __formatSignature = (plugin, entry) => {
+  const fields = Object.entries(entry.inputs || {})
+    .map(([k, v]) => k + (v.required ? '' : '?') + ': ' + v.type)
+    .join(', ');
+  return plugin + '.' + entry.action + (fields ? '({ ' + fields + ' })' : '()');
+};
+
+// Build a MiniSearch index over every action path. Indexed at sandbox
+// startup, queried by actions.find().
+const __search = (() => {
+  const docs = [];
+  for (const path of Object.keys(__index)) {
+    const { plugin, entry } = __index[path];
+    docs.push({
+      id: path,
+      path,
+      plugin,
+      action: entry.action,
+      description: entry.description || '',
+    });
+  }
+  const ms = new MiniSearch({
+    fields: ['path', 'plugin', 'action', 'description'],
+    storeFields: ['path', 'description'],
+    searchOptions: {
+      prefix: true,
+      fuzzy: 0.2,
+      boost: { path: 3, action: 2, plugin: 2 },
+    },
+  });
+  ms.addAll(docs);
+  return ms;
+})();
+
+const __actionsApi = {
+  list(plugin) {
+    const paths = Object.keys(__index);
+    return plugin ? paths.filter((p) => p.startsWith(plugin + '.')) : paths;
+  },
+  describe(path) {
+    const hit = __index[path];
+    if (!hit) {
+      const near = __actionsApi.find(path, 3);
+      const hint = near.length ? ' Did you mean: ' + near.map((n) => n.path).join(', ') + '?' : '';
+      throw new Error('Unknown action: ' + path + '.' + hint);
+    }
+    return {
+      path,
+      plugin: hit.plugin,
+      action: hit.entry.action,
+      description: hit.entry.description,
+      signature: __formatSignature(hit.plugin, hit.entry),
+      inputs: hit.entry.inputs,
+    };
+  },
+  find(query, limit = 5) {
+    const q = String(query || '').trim();
+    if (!q) return [];
+    return __search.search(q).slice(0, limit).map((r) => ({
+      path: r.path,
+      description: r.description || undefined,
+      score: r.score,
+    }));
+  },
+  check(path, args) {
+    const hit = __index[path];
+    if (!hit) {
+      const near = __actionsApi.find(path, 3).map((n) => n.path);
+      return { ok: false, error: 'Unknown action: ' + path, suggestions: near };
+    }
+    const inputs = hit.entry.inputs || {};
+    const provided = args && typeof args === 'object' ? args : {};
+    const missing = [];
+    const unknown = [];
+    const typeErrors = [];
+    for (const [k, spec] of Object.entries(inputs)) {
+      if (spec.required && !(k in provided)) missing.push(k);
+    }
+    for (const k of Object.keys(provided)) {
+      if (!(k in inputs)) unknown.push(k);
+      else {
+        const expected = inputs[k].type;
+        const actual = Array.isArray(provided[k]) ? 'array' : typeof provided[k];
+        if (expected !== actual && !(provided[k] === null || provided[k] === undefined)) {
+          typeErrors.push({ field: k, expected, actual });
+        }
+      }
+    }
+    return {
+      ok: missing.length === 0 && unknown.length === 0 && typeErrors.length === 0,
+      missing,
+      unknown,
+      typeErrors,
+      signature: __formatSignature(hit.plugin, hit.entry),
+    };
+  },
+};
+
+// Unknown keys (plugin names) fall through to the call proxy, so
+// actions.github.issue.create(...) keeps working alongside the explicit
+// list/find/describe/check/help helpers.
+const actions = new Proxy(__actionsApi, {
+  get(target, prop) {
+    if (prop in target || typeof prop === 'symbol') return target[prop];
+    return __makeProxy([String(prop)]);
+  },
+});
+
 ${pluginNames.map((n) => `const ${n} = __makeProxy(['${n}']);`).join("\n")}
 
 const console = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Code mode for agents — turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
@@ -25,7 +25,8 @@
     "runline": "./dist/main.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "vendor"
   ],
   "scripts": {
     "build": "tsc && bun --filter runline-plugins build && rm -rf dist/plugins && cp -R ../runline-plugins/dist dist/plugins",
@@ -58,6 +59,7 @@
     "@types/bun": "^1.2.17",
     "@types/node": "^25.5.0",
     "@types/proper-lockfile": "^4.1.4",
+    "minisearch": "^7.2.0",
     "typescript": "^5.8.0"
   },
   "dependencies": {

package/vendor/README.md

@@ -0,0 +1,19 @@
+# vendor
+
+Third-party bundles inlined into the QuickJS sandbox at runtime.
+
+These files are committed deliberately: the sandbox eval'd source is part of runline's behavior, and PR diffs should show exactly what changes when a bundle is bumped.
+
+## minisearch.umd.js
+
+UMD build of [minisearch](https://github.com/lucaong/minisearch). Read by `src/core/engine.ts` and inlined into the sandbox so `MiniSearch` is available as a global to agent code (powers `actions.find()`).
+
+To upgrade:
+
+```bash
+npm i -D minisearch@latest
+cp node_modules/minisearch/dist/umd/index.js vendor/minisearch.umd.js
+git commit -am "vendor: bump minisearch"
+```
+
+The `minisearch` devDependency exists only as a convenience for that `cp` — nothing imports it at runtime.