@rong/agentscript 0.1.0

package/dist/providers/memory/shared.js

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import { RuntimeError } from "../../runtime/errors.js";
+import { isObject } from "../../runtime/guards.js";
+import { runtimeValuesEqual, sanitizeForJson } from "../../runtime/json.js";
+export function readLimit(value) {
+    if (value === undefined || value === null)
+        return 10;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new RuntimeError("memory.query limit must be a positive integer");
+    }
+    return value;
+}
+export function createMemoryEnvelope(record) {
+    const now = new Date().toISOString();
+    return {
+        id: randomUUID(),
+        created_at: now,
+        updated_at: now,
+        record,
+    };
+}
+export function matchesQuery(record, query) {
+    if (typeof query.kind === "string" && record.kind !== query.kind)
+        return false;
+    if (typeof query.text === "string" && !matchesText(record, query.text))
+        return false;
+    if (query.where !== undefined) {
+        if (!isObject(query.where)) {
+            throw new RuntimeError("memory.query where must be an object");
+        }
+        for (const [key, expected] of Object.entries(query.where)) {
+            if (!(key in record) || !runtimeValuesEqual(record[key], expected))
+                return false;
+        }
+    }
+    return true;
+}
+export function isMemoryEnvelope(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const item = value;
+    return (typeof item.id === "string" &&
+        typeof item.created_at === "string" &&
+        typeof item.updated_at === "string" &&
+        typeof item.record === "object" &&
+        item.record !== null &&
+        !Array.isArray(item.record));
+}
+function matchesText(record, text) {
+    const needle = text.toLowerCase();
+    const candidates = [
+        typeof record.text === "string" ? record.text : "",
+        JSON.stringify(sanitizeForJson(record)),
+    ];
+    return candidates.some((candidate) => candidate.toLowerCase().includes(needle));
+}

package/dist/providers/memory/sqlite.js

@@ -0,0 +1,98 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { RuntimeError } from "../../runtime/errors.js";
+import { isObject } from "../../runtime/guards.js";
+import { createMemoryEnvelope, matchesQuery, readLimit } from "./shared.js";
+export class SqliteMemoryBackend {
+    add(request, target) {
+        mkdirSync(dirname(target.path), { recursive: true });
+        const db = openSqlite(target.path);
+        try {
+            const envelope = createMemoryEnvelope(request.record);
+            db.prepare(`
+        INSERT INTO memory_records (namespace, id, created_at, updated_at, kind, text, record_json)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(target.namespace, envelope.id, envelope.created_at, envelope.updated_at, typeof envelope.record.kind === "string" ? envelope.record.kind : null, typeof envelope.record.text === "string" ? envelope.record.text : null, JSON.stringify(envelope.record));
+            return envelope;
+        }
+        finally {
+            db.close();
+        }
+    }
+    query(request, target) {
+        const query = request.query;
+        const limit = readLimit(query.limit);
+        if (!existsSync(target.path))
+            return [];
+        const db = openSqlite(target.path);
+        try {
+            const conditions = ["namespace = ?"];
+            const params = [target.namespace];
+            if (typeof query.kind === "string") {
+                conditions.push("kind = ?");
+                params.push(query.kind);
+            }
+            if (typeof query.text === "string") {
+                conditions.push("(text LIKE ? ESCAPE '\\' OR record_json LIKE ? ESCAPE '\\')");
+                const pattern = `%${escapeLike(query.text)}%`;
+                params.push(pattern, pattern);
+            }
+            const needPostFilter = query.where !== undefined;
+            const sql = `
+        SELECT id, created_at, updated_at, record_json
+        FROM memory_records
+        WHERE ${conditions.join(" AND ")}
+        ORDER BY created_at DESC
+        ${needPostFilter ? "" : "LIMIT ?"}
+      `;
+            const sqlParams = needPostFilter ? params : [...params, limit];
+            const rows = db.prepare(sql).all(...sqlParams);
+            const records = rows
+                .map((row) => rowToEnvelope(row))
+                .filter((item) => matchesQuery(item.record, query));
+            return records.slice(0, limit);
+        }
+        finally {
+            db.close();
+        }
+    }
+}
+function openSqlite(path) {
+    const db = new DatabaseSync(path);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_records (
+      namespace TEXT NOT NULL,
+      id TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      kind TEXT,
+      text TEXT,
+      record_json TEXT NOT NULL,
+      PRIMARY KEY (namespace, id)
+    )
+  `);
+    return db;
+}
+function rowToEnvelope(row) {
+    let record;
+    try {
+        record = JSON.parse(row.record_json);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RuntimeError(`Invalid sqlite memory record '${row.id}': ${message}`);
+    }
+    if (!isObject(record)) {
+        throw new RuntimeError(`Invalid sqlite memory record '${row.id}': record_json must be an object`);
+    }
+    return {
+        id: row.id,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        record,
+    };
+}
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}

package/dist/providers/mock/index.js

@@ -0,0 +1,32 @@
+import { sanitizeForJson } from "../../runtime/json.js";
+import { buildValueFromShape } from "../../runtime/shape.js";
+export class MockLlmProvider {
+    async generate(request) {
+        return buildValueFromShape(request.returnShape);
+    }
+}
+export class MockToolProvider {
+    async call(request) {
+        return {
+            summary: `${request.toolName}.${request.method}`,
+            source: request.uri,
+            args: sanitizeForJson(request.args)
+        };
+    }
+}
+export class MockMemoryProvider {
+    records = [];
+    async add(request) {
+        const record = {
+            id: String(this.records.length + 1),
+            created_at: "mock",
+            updated_at: "mock",
+            record: request.record
+        };
+        this.records.push(record);
+        return record;
+    }
+    async query(_request) {
+        return [...this.records].reverse();
+    }
+}

package/dist/providers/tools/env.js

@@ -0,0 +1,11 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { expectObject, readRequiredString } from "./shared.js";
+export class EnvToolProvider {
+    async call(request) {
+        if (request.method !== "get") {
+            throw new RuntimeError(`Unsupported env method '${request.method}'. Supported: get`);
+        }
+        const args = expectObject(request.args[0], "Env.get");
+        return process.env[readRequiredString(args.name, "Env.get.name")] ?? null;
+    }
+}

package/dist/providers/tools/file.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { RuntimeError } from "../../runtime/errors.js";
+import { isObject } from "../../runtime/guards.js";
+import { expectObject, readRequiredString } from "./shared.js";
+const FILE_EFFECT_ACTIONS = new Set(["write", "patch"]);
+export class FileToolProvider {
+    workspace;
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    async call(request) {
+        if (request.method === "undo") {
+            return this.undoFileEffects(request.args[0]);
+        }
+        const args = expectObject(request.args[0], `File.${request.method}`);
+        switch (request.method) {
+            case "read":
+                return readFileSync(this.workspace.resolveWorkspacePath(readRequiredString(args.path, "File.read.path")), "utf8");
+            case "list": {
+                const path = this.workspace.resolveWorkspacePath(readRequiredString(args.path, "File.list.path"));
+                return readdirSync(path).map((entry) => entry);
+            }
+            case "write":
+                return this.writeFile(request.toolName, args);
+            case "patch":
+                return this.patchFile(request.toolName, args);
+            default:
+                throw new RuntimeError(`Unsupported file method '${request.method}'. Supported: read, list, write, patch, undo`);
+        }
+    }
+    writeFile(toolName, args) {
+        const path = this.workspace.resolveWorkspacePath(readRequiredString(args.path, "File.write.path"));
+        const relPath = this.workspace.workspaceRelativePath(path);
+        const content = readRequiredString(args.content, "File.write.content");
+        const existed = existsSync(path);
+        const previous = existed ? readFileSync(path, "utf8") : null;
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content);
+        return fileEffectResult({
+            id: `file-write:${relPath}`,
+            tool: toolName,
+            action: "write",
+            path: relPath,
+            undoable: true,
+            existed,
+            previous,
+        });
+    }
+    patchFile(toolName, args) {
+        const path = this.workspace.resolveWorkspacePath(readRequiredString(args.path, "File.patch.path"));
+        const relPath = this.workspace.workspaceRelativePath(path);
+        const search = readRequiredString(args.search, "File.patch.search");
+        const replace = readRequiredString(args.replace, "File.patch.replace");
+        const previous = readFileSync(path, "utf8");
+        if (search.length === 0 || !previous.includes(search)) {
+            return { ok: false, error: "patch search text not found", effects: [] };
+        }
+        writeFileSync(path, previous.replace(search, replace));
+        return fileEffectResult({
+            id: `file-patch:${relPath}`,
+            tool: toolName,
+            action: "patch",
+            path: relPath,
+            undoable: true,
+            previous,
+        });
+    }
+    undoFileEffects(value) {
+        if (!Array.isArray(value)) {
+            throw new RuntimeError("File.undo expects a list of effects");
+        }
+        for (const effect of value) {
+            if (!isFileEffect(effect))
+                continue;
+            const path = this.workspace.resolveWorkspacePath(effect.path);
+            if (typeof effect.previous === "string") {
+                writeFileSync(path, effect.previous);
+            }
+            else if (effect.existed === false && existsSync(path)) {
+                rmSync(path);
+            }
+        }
+        return { ok: true };
+    }
+}
+function fileEffectResult(effect) {
+    return {
+        ok: true,
+        effects: [effect],
+    };
+}
+function isFileEffect(value) {
+    return (isObject(value) &&
+        typeof value.action === "string" &&
+        FILE_EFFECT_ACTIONS.has(value.action) &&
+        typeof value.path === "string" &&
+        typeof value.undoable === "boolean");
+}

package/dist/providers/tools/host.js

@@ -0,0 +1,34 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { uriScheme } from "../../runtime/uri.js";
+import { EnvToolProvider } from "./env.js";
+import { FileToolProvider } from "./file.js";
+import { HttpToolProvider } from "./http.js";
+import { SchemeToolProvider } from "./scheme.js";
+import { ShellToolProvider } from "./shell.js";
+import { Workspace } from "./shared.js";
+export class HostToolProvider {
+    providers;
+    constructor(workspaceRoot = process.cwd()) {
+        const workspace = new Workspace(workspaceRoot);
+        const http = new HttpToolProvider();
+        this.providers = {
+            env: new EnvToolProvider(),
+            file: new FileToolProvider(workspace),
+            http,
+            https: http,
+            sh: new ShellToolProvider(workspace),
+        };
+    }
+    async call(request) {
+        const scheme = uriScheme(request.uri);
+        const provider = this.providers[scheme];
+        if (!provider) {
+            throw new RuntimeError(`Unsupported host tool scheme '${scheme}'`);
+        }
+        return provider.call(request);
+    }
+}
+export function createDefaultToolProvider(workspaceRoot = process.cwd()) {
+    const host = new HostToolProvider(workspaceRoot);
+    return new SchemeToolProvider({ env: host, file: host, http: host, https: host, sh: host });
+}

package/dist/providers/tools/http.js

@@ -0,0 +1,40 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { isObject } from "../../runtime/guards.js";
+import { sanitizeForJson } from "../../runtime/json.js";
+import { expectObject, parseJsonOrNull, readPositiveInteger, readRequiredString } from "./shared.js";
+const DEFAULT_HTTP_TIMEOUT_MS = 10_000;
+export class HttpToolProvider {
+    async call(request) {
+        const args = expectObject(request.args[0], `Http.${request.method}`);
+        const url = resolveHttpUrl(request.uri, readRequiredString(args.url, "Http.url"));
+        const timeout = readPositiveInteger(args.timeout, DEFAULT_HTTP_TIMEOUT_MS);
+        const controller = new AbortController();
+        const init = {
+            method: request.method.toUpperCase(),
+            signal: controller.signal,
+        };
+        if (isObject(args.headers)) {
+            init.headers = sanitizeForJson(args.headers);
+        }
+        if ("body" in args) {
+            init.body = typeof args.body === "string" ? args.body : JSON.stringify(sanitizeForJson(args.body));
+        }
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, init);
+            const text = await response.text();
+            return { ok: response.ok, status: response.status, body: text, json: parseJsonOrNull(text) };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+function resolveHttpUrl(importUri, requestedUrl) {
+    const base = new URL(importUri);
+    const target = new URL(requestedUrl, base);
+    if (target.origin !== base.origin) {
+        throw new RuntimeError(`HTTP tool URL origin '${target.origin}' does not match import origin '${base.origin}'`);
+    }
+    return target.toString();
+}

package/dist/providers/tools/index.js

@@ -0,0 +1,2 @@
+export * from "./host.js";
+export * from "./scheme.js";

package/dist/providers/tools/scheme.js

@@ -0,0 +1,16 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { uriScheme } from "../../runtime/uri.js";
+export class SchemeToolProvider {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    async call(request) {
+        const scheme = uriScheme(request.uri);
+        const provider = this.providers[scheme];
+        if (!provider) {
+            throw new RuntimeError(`Unsupported tool URI scheme '${scheme}'`);
+        }
+        return provider.call(request);
+    }
+}

package/dist/providers/tools/shared.js

@@ -0,0 +1,92 @@
+import { existsSync, lstatSync, realpathSync, readdirSync, statSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
+import { RuntimeError } from "../../runtime/errors.js";
+import { isObject } from "../../runtime/guards.js";
+import { sanitizeForJson } from "../../runtime/json.js";
+export const DEFAULT_MAX_RESULTS = 100;
+export class Workspace {
+    workspaceRoot;
+    constructor(workspaceRoot = process.cwd()) {
+        this.workspaceRoot = realpathSync(resolve(workspaceRoot));
+    }
+    resolveWorkspacePath(path) {
+        const resolved = resolve(this.workspaceRoot, path);
+        if (resolved !== this.workspaceRoot && !resolved.startsWith(`${this.workspaceRoot}${sep}`)) {
+            throw new RuntimeError(`Path escapes workspace: ${path}`);
+        }
+        if (existsSync(resolved)) {
+            const real = realpathSync(resolved);
+            if (real !== this.workspaceRoot && !real.startsWith(`${this.workspaceRoot}${sep}`)) {
+                throw new RuntimeError(`Path escapes workspace: ${path}`);
+            }
+        }
+        return resolved;
+    }
+    workspaceRelativePath(path) {
+        return relative(this.workspaceRoot, path);
+    }
+    visitWorkspaceTree(root, visitor) {
+        const visit = (path) => {
+            const linkStat = lstatSync(path);
+            if (linkStat.isSymbolicLink())
+                return true;
+            const stat = statSync(path);
+            const relativePath = relative(this.workspaceRoot, path) || ".";
+            if (visitor(path, relativePath, stat) === false)
+                return false;
+            if (stat.isDirectory()) {
+                for (const entry of readdirSync(path)) {
+                    if (visit(resolve(path, entry)) === false)
+                        return false;
+                }
+            }
+            return true;
+        };
+        if (existsSync(root))
+            visit(root);
+    }
+}
+export function expectObject(value, call) {
+    if (!isObject(value ?? null)) {
+        throw new RuntimeError(`${call} expects one json object argument`);
+    }
+    return value;
+}
+export function readRequiredString(value, name) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new RuntimeError(`${name} is required`);
+    }
+    return value;
+}
+export function readOptionalString(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new RuntimeError(`Expected a string, got ${JSON.stringify(sanitizeForJson(value))}`);
+    }
+    return value;
+}
+export function readPositiveInteger(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value === "number" && Number.isInteger(value) && value > 0)
+        return value;
+    throw new RuntimeError(`Expected a positive integer, got ${JSON.stringify(sanitizeForJson(value))}`);
+}
+export function globMatcher(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`(^|/)${escaped}$`);
+    return (value) => regex.test(value);
+}
+export function toolUriTarget(uri) {
+    const parsed = new URL(uri);
+    return parsed.hostname || parsed.pathname.replace(/^\//, "");
+}
+export function parseJsonOrNull(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/providers/tools/shell.js

@@ -0,0 +1,80 @@
+import { readFileSync } from "node:fs";
+import { RuntimeError } from "../../runtime/errors.js";
+import { DEFAULT_MAX_RESULTS, expectObject, globMatcher, readOptionalString, readPositiveInteger, readRequiredString, toolUriTarget, } from "./shared.js";
+const FORBIDDEN_SHELL_TOOLS = new Set(["sh", "bash", "zsh", "fish"]);
+const SUPPORTED_SHELL_COMMANDS = new Set(["find", "grep", "sed"]);
+const MAX_GREP_FILE_BYTES = 1024 * 1024;
+export class ShellToolProvider {
+    workspace;
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    async call(request) {
+        const command = toolUriTarget(request.uri);
+        if (FORBIDDEN_SHELL_TOOLS.has(command)) {
+            throw new RuntimeError(`Forbidden shell tool '${command}'`);
+        }
+        switch (command) {
+            case "find":
+                return this.runFind(request.args[0]);
+            case "grep":
+                return this.runGrep(request.args[0]);
+            case "sed":
+                return this.runSed(request.args[0]);
+            default:
+                throw new RuntimeError(`Unsupported shell tool '${command}'. Supported: ${[...SUPPORTED_SHELL_COMMANDS].join(", ")}`);
+        }
+    }
+    runFind(value) {
+        const args = expectObject(value, "Find.run");
+        const root = this.workspace.resolveWorkspacePath(readRequiredString(args.path, "Find.run.path"));
+        const name = readOptionalString(args.name);
+        const type = readOptionalString(args.type);
+        const max = readPositiveInteger(args.max, DEFAULT_MAX_RESULTS);
+        const matcher = name ? globMatcher(name) : undefined;
+        const results = [];
+        this.workspace.visitWorkspaceTree(root, (_path, relativePath, stat) => {
+            const kind = stat.isDirectory() ? "dir" : "file";
+            if ((!type || type === kind) && (!matcher || matcher(relativePath))) {
+                results.push(relativePath);
+            }
+            return results.length < max;
+        });
+        return { ok: true, files: results };
+    }
+    runGrep(value) {
+        const args = expectObject(value, "Grep.run");
+        const root = this.workspace.resolveWorkspacePath(readRequiredString(args.path, "Grep.run.path"));
+        const pattern = readRequiredString(args.pattern, "Grep.run.pattern");
+        const include = readOptionalString(args.include);
+        const max = readPositiveInteger(args.max, DEFAULT_MAX_RESULTS);
+        const matcher = include ? globMatcher(include) : undefined;
+        const matches = [];
+        this.workspace.visitWorkspaceTree(root, (path, relativePath, stat) => {
+            if (stat.isDirectory())
+                return true;
+            if (matcher && !matcher(relativePath))
+                return true;
+            if (stat.size > MAX_GREP_FILE_BYTES)
+                return true;
+            const lines = readFileSync(path, "utf8").split(/\r?\n/);
+            for (const [index, line] of lines.entries()) {
+                if (line.includes(pattern)) {
+                    matches.push({ path: relativePath, line: index + 1, text: line });
+                    if (matches.length >= max)
+                        return false;
+                }
+            }
+            return true;
+        });
+        return { ok: true, matches };
+    }
+    runSed(value) {
+        const args = expectObject(value, "Sed.run");
+        const path = this.workspace.resolveWorkspacePath(readRequiredString(args.path, "Sed.run.path"));
+        const start = readPositiveInteger(args.start, 1);
+        const max = readPositiveInteger(args.max, DEFAULT_MAX_RESULTS);
+        const lines = readFileSync(path, "utf8").split(/\r?\n/).slice(start - 1, start - 1 + max);
+        return { ok: true, text: lines.join("\n"), start, end: start + lines.length - 1 };
+    }
+}