@rong/agentscript 0.1.0

package/dist/parser/tokenizer.js

@@ -0,0 +1,246 @@
+import { ParseError } from "./errors.js";
+const KEYWORDS = new Set([
+    "import",
+    "main",
+    "agent",
+    "func",
+    "use",
+    "loop",
+    "until",
+    "repeat",
+    "for",
+    "in",
+    "return",
+    "if",
+    "else",
+    "and",
+    "or",
+    "not",
+    "generate",
+    "from",
+    "true",
+    "false",
+    "none",
+    "string",
+    "number",
+    "boolean",
+    "json",
+    "list"
+]);
+const SYMBOLS = new Set([
+    "{",
+    "}",
+    "(",
+    ")",
+    "[",
+    "]",
+    ".",
+    ",",
+    ":",
+    "=",
+    "!",
+    "<",
+    "*"
+]);
+export function tokenize(source) {
+    const scanner = new Scanner(source);
+    return scanner.scanAll();
+}
+class Scanner {
+    source;
+    offset = 0;
+    line = 1;
+    column = 1;
+    constructor(source) {
+        this.source = source;
+    }
+    scanAll() {
+        const tokens = [];
+        while (!this.isAtEnd()) {
+            this.skipWhitespaceAndComments();
+            if (this.isAtEnd()) {
+                break;
+            }
+            const start = this.location();
+            const char = this.peek();
+            if (char === '"' || char === "'") {
+                tokens.push(this.scanString());
+                continue;
+            }
+            if (isDigit(char)) {
+                tokens.push(this.scanNumber());
+                continue;
+            }
+            if (isIdentifierStart(char)) {
+                tokens.push(this.scanIdentifier());
+                continue;
+            }
+            if (SYMBOLS.has(char)) {
+                const twoChar = `${char}${this.peekNext()}`;
+                if (twoChar === "==" || twoChar === "!=") {
+                    this.advance();
+                    this.advance();
+                    tokens.push({
+                        kind: "symbol",
+                        value: twoChar,
+                        range: { start, end: this.location() }
+                    });
+                    continue;
+                }
+                this.advance();
+                tokens.push({
+                    kind: "symbol",
+                    value: char,
+                    range: { start, end: this.location() }
+                });
+                continue;
+            }
+            throw new ParseError(`Unexpected character '${char}'`, start);
+        }
+        const location = this.location();
+        tokens.push({
+            kind: "eof",
+            value: "",
+            range: { start: location, end: location }
+        });
+        return tokens;
+    }
+    scanString() {
+        const quote = this.peek();
+        const start = this.location();
+        this.advance();
+        let value = "";
+        while (!this.isAtEnd() && this.peek() !== quote) {
+            const char = this.advance();
+            if (char === "\\") {
+                value += this.scanEscape(start);
+            }
+            else {
+                value += char;
+            }
+        }
+        if (this.isAtEnd()) {
+            throw new ParseError("Unterminated string literal", start);
+        }
+        this.advance();
+        return {
+            kind: "string",
+            value,
+            range: { start, end: this.location() }
+        };
+    }
+    scanEscape(start) {
+        if (this.isAtEnd()) {
+            throw new ParseError("Unterminated escape sequence", start);
+        }
+        const escaped = this.advance();
+        switch (escaped) {
+            case "n":
+                return "\n";
+            case "r":
+                return "\r";
+            case "t":
+                return "\t";
+            case "\\":
+                return "\\";
+            case '"':
+                return '"';
+            case "'":
+                return "'";
+            default:
+                return escaped;
+        }
+    }
+    scanNumber() {
+        const start = this.location();
+        let value = "";
+        while (!this.isAtEnd() && isDigit(this.peek())) {
+            value += this.advance();
+        }
+        if (!this.isAtEnd() && this.peek() === ".") {
+            value += this.advance();
+            while (!this.isAtEnd() && isDigit(this.peek())) {
+                value += this.advance();
+            }
+        }
+        if (!this.isAtEnd() && isIdentifierStart(this.peek())) {
+            while (!this.isAtEnd() && isIdentifierPart(this.peek())) {
+                value += this.advance();
+            }
+        }
+        return {
+            kind: "number",
+            value,
+            range: { start, end: this.location() }
+        };
+    }
+    scanIdentifier() {
+        const start = this.location();
+        let value = "";
+        while (!this.isAtEnd() && isIdentifierPart(this.peek())) {
+            value += this.advance();
+        }
+        return {
+            kind: KEYWORDS.has(value) ? "keyword" : "identifier",
+            value,
+            range: { start, end: this.location() }
+        };
+    }
+    skipWhitespaceAndComments() {
+        while (!this.isAtEnd()) {
+            while (!this.isAtEnd() && isWhitespace(this.peek())) {
+                this.advance();
+            }
+            if (this.peek() === "/" && this.peekNext() === "/") {
+                while (!this.isAtEnd() && this.peek() !== "\n") {
+                    this.advance();
+                }
+                continue;
+            }
+            return;
+        }
+    }
+    peek() {
+        return this.source[this.offset] ?? "\0";
+    }
+    peekNext() {
+        return this.source[this.offset + 1] ?? "\0";
+    }
+    advance() {
+        const char = this.source[this.offset] ?? "\0";
+        this.offset += 1;
+        if (char === "\n") {
+            this.line += 1;
+            this.column = 1;
+        }
+        else {
+            this.column += 1;
+        }
+        return char;
+    }
+    isAtEnd() {
+        return this.offset >= this.source.length;
+    }
+    location() {
+        return {
+            line: this.line,
+            column: this.column,
+            offset: this.offset
+        };
+    }
+}
+function isWhitespace(char) {
+    return char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+function isDigit(char) {
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57;
+}
+function isIdentifierStart(char) {
+    const code = char.charCodeAt(0);
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95;
+}
+function isIdentifierPart(char) {
+    const code = char.charCodeAt(0);
+    return isIdentifierStart(char) || (code >= 48 && code <= 57) || code === 45;
+}

package/dist/providers/llm/anthropic.js

@@ -0,0 +1,36 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { budgetToTokenLimit, parseJsonText, postJson } from "./shared.js";
+export async function callAnthropic(request, parsed, options, fetchImpl, timeoutMs, baseUrl) {
+    const apiKey = options.anthropicApiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        throw new RuntimeError("ANTHROPIC_API_KEY is required for anthropic:// models");
+    }
+    const response = await postJson(fetchImpl, `${baseUrl}/messages`, {
+        model: parsed.model,
+        max_tokens: budgetToTokenLimit(request) ?? 1024,
+        system: request.builtContext.system,
+        messages: [
+            {
+                role: "user",
+                content: request.builtContext.finalUserMessage,
+            },
+        ],
+    }, timeoutMs, {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+    });
+    return parseJsonText(readAnthropicText(response));
+}
+function readAnthropicText(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || !Array.isArray(value.content)) {
+        throw new RuntimeError("Anthropic response is missing content");
+    }
+    return value.content.filter(isAnthropicTextBlock).map((block) => block.text).join("");
+}
+function isAnthropicTextBlock(block) {
+    return (block != null &&
+        typeof block === "object" &&
+        !Array.isArray(block) &&
+        block.type === "text" &&
+        typeof block.text === "string");
+}

package/dist/providers/llm/index.js

@@ -0,0 +1,3 @@
+export * from "./protocol.js";
+export * from "./types.js";
+export * from "./uri.js";

package/dist/providers/llm/ollama.js

@@ -0,0 +1,19 @@
+import { budgetToTokenLimit, parseJsonText, postJson, readPath } from "./shared.js";
+export async function callOllama(request, parsed, fetchImpl, timeoutMs, baseUrl) {
+    const body = {
+        model: parsed.model,
+        stream: false,
+        think: false,
+        format: request.builtContext.returnSchema,
+        messages: [
+            { role: "system", content: request.builtContext.system },
+            { role: "user", content: request.builtContext.finalUserMessage },
+        ],
+    };
+    const maxTokens = budgetToTokenLimit(request);
+    if (maxTokens) {
+        body.options = { num_predict: maxTokens };
+    }
+    const response = await postJson(fetchImpl, `${baseUrl}/api/chat`, body, timeoutMs);
+    return parseJsonText(readPath(response, ["message", "content"]));
+}

package/dist/providers/llm/openai.js

@@ -0,0 +1,31 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { budgetToTokenLimit, parseJsonText, postJson, readPath } from "./shared.js";
+export async function callOpenAI(request, parsed, options, fetchImpl, timeoutMs, baseUrl) {
+    const apiKey = options.openaiApiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        throw new RuntimeError("OPENAI_API_KEY is required for openai:// models");
+    }
+    const body = {
+        model: parsed.model,
+        messages: [
+            { role: "system", content: request.builtContext.system },
+            { role: "user", content: request.builtContext.finalUserMessage },
+        ],
+        response_format: {
+            type: "json_schema",
+            json_schema: {
+                name: "agentscript_generate",
+                strict: true,
+                schema: request.builtContext.returnSchema,
+            },
+        },
+    };
+    const maxTokens = budgetToTokenLimit(request);
+    if (maxTokens) {
+        body.max_completion_tokens = maxTokens;
+    }
+    const response = await postJson(fetchImpl, `${baseUrl}/chat/completions`, body, timeoutMs, {
+        authorization: `Bearer ${apiKey}`,
+    });
+    return parseJsonText(readPath(response, ["choices", 0, "message", "content"]));
+}

package/dist/providers/llm/protocol.js

@@ -0,0 +1,45 @@
+import { RuntimeError } from "../../runtime/errors.js";
+import { callAnthropic } from "./anthropic.js";
+import { callOllama } from "./ollama.js";
+import { callOpenAI } from "./openai.js";
+import { trimTrailingSlash } from "./shared.js";
+import { parseLlmUri } from "./uri.js";
+export class ProtocolLlmProvider {
+    options;
+    fetchImpl;
+    constructor(options = {}) {
+        this.options = options;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async generate(request) {
+        if (!request.model) {
+            throw new RuntimeError("A real LLM provider requires an agent model declaration");
+        }
+        const parsed = parseLlmUri(request.model);
+        const timeoutMs = this.requestTimeoutMs();
+        switch (parsed.protocol) {
+            case "openai":
+                return callOpenAI(request, parsed, this.options, this.fetchImpl, timeoutMs, this.openAIBaseUrl(parsed));
+            case "anthropic":
+                return callAnthropic(request, parsed, this.options, this.fetchImpl, timeoutMs, this.anthropicBaseUrl(parsed));
+            case "ollama":
+                return callOllama(request, parsed, this.fetchImpl, timeoutMs, this.ollamaBaseUrl(parsed));
+        }
+    }
+    requestTimeoutMs() {
+        const value = this.options.timeoutMs ?? Number.parseInt(process.env.AGENTSCRIPT_LLM_TIMEOUT_MS ?? "", 10);
+        return Number.isFinite(value) && value > 0 ? value : 30_000;
+    }
+    openAIBaseUrl(parsed) {
+        return this.providerBaseUrl(parsed, this.options.openaiBaseUrl, "OPENAI_BASE_URL", "https://api.openai.com/v1");
+    }
+    anthropicBaseUrl(parsed) {
+        return this.providerBaseUrl(parsed, this.options.anthropicBaseUrl, "ANTHROPIC_BASE_URL", "https://api.anthropic.com/v1");
+    }
+    ollamaBaseUrl(parsed) {
+        return this.providerBaseUrl(parsed, this.options.ollamaBaseUrl, "OLLAMA_BASE_URL", "http://localhost:11434");
+    }
+    providerBaseUrl(parsed, configuredUrl, environmentName, fallback) {
+        return trimTrailingSlash(parsed.baseUrl ?? configuredUrl ?? process.env[environmentName] ?? fallback);
+    }
+}

package/dist/providers/llm/shared.js

@@ -0,0 +1,147 @@
+import { RuntimeError } from "../../runtime/errors.js";
+export function budgetToTokenLimit(request) {
+    if (!request.budget) {
+        return undefined;
+    }
+    if (request.budget.unit === "k") {
+        return Math.max(1, Math.floor(request.budget.amount * 1000));
+    }
+    return Math.max(1, Math.floor(request.budget.amount));
+}
+export async function postJson(fetchImpl, url, body, timeoutMs, headers = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+        response = await fetchImpl(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...headers,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (controller.signal.aborted) {
+            throw new RuntimeError(`LLM provider request timed out after ${timeoutMs}ms: ${url}`);
+        }
+        throw new RuntimeError(`LLM provider request failed: ${message}`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    const text = await response.text();
+    if (!response.ok) {
+        throw new RuntimeError(`LLM provider request failed (${response.status}): ${text}`);
+    }
+    return parseProviderJson(text);
+}
+export function parseJsonText(text) {
+    const candidates = [text, ...extractJsonCandidates(text)];
+    try {
+        return JSON.parse(candidates[0]);
+    }
+    catch {
+        for (const candidate of candidates.slice(1)) {
+            try {
+                return JSON.parse(candidate);
+            }
+            catch {
+                continue;
+            }
+        }
+        throw new RuntimeError(`LLM provider did not return JSON: ${snippet(text)}`);
+    }
+}
+export function readPath(value, path) {
+    let current = value;
+    for (const segment of path) {
+        if (current === null || current === undefined) {
+            break;
+        }
+        if (Array.isArray(current) && typeof segment === "number") {
+            current = current[segment];
+        }
+        else if (typeof current === "object" && typeof segment === "string") {
+            current = current[segment];
+        }
+        else {
+            current = undefined;
+        }
+    }
+    if (typeof current !== "string") {
+        throw new RuntimeError(`LLM provider response is missing '${path.join(".")}'`);
+    }
+    return current;
+}
+export function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function extractJsonCandidates(text) {
+    const candidates = [];
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/gi;
+    for (const match of text.matchAll(fenced)) {
+        if (match[1]) {
+            candidates.push(match[1].trim());
+        }
+    }
+    const object = extractFirstJsonObject(text);
+    if (object) {
+        candidates.push(object);
+    }
+    return candidates;
+}
+function extractFirstJsonObject(text) {
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (start >= 0 && inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (start >= 0 && char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            if (start < 0) {
+                start = index;
+            }
+            depth += 1;
+            continue;
+        }
+        if (char === "}" && start >= 0) {
+            depth -= 1;
+            if (depth === 0) {
+                return text.slice(start, index + 1);
+            }
+        }
+    }
+    return undefined;
+}
+function parseProviderJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new RuntimeError(`LLM provider returned invalid JSON response: ${snippet(text)}`);
+    }
+}
+function snippet(text) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
+}

package/dist/providers/llm/types.js

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

package/dist/providers/llm/uri.js

@@ -0,0 +1,24 @@
+import { RuntimeError } from "../../runtime/errors.js";
+const SUPPORTED_LLM_PROTOCOLS = new Set(["openai:", "anthropic:", "ollama:"]);
+export function parseLlmUri(model) {
+    if (!model.uri.includes("://")) {
+        throw new RuntimeError("LLM URI must use an explicit protocol URL form");
+    }
+    const url = new URL(model.uri);
+    if (!SUPPORTED_LLM_PROTOCOLS.has(url.protocol)) {
+        throw new RuntimeError(`Unsupported LLM provider protocol '${url.protocol.replace(":", "")}'`);
+    }
+    const protocol = url.protocol.slice(0, -1);
+    if (protocol === "ollama" && url.pathname.length > 1 && url.hostname) {
+        return {
+            protocol,
+            model: decodeURIComponent(url.pathname.slice(1)),
+            baseUrl: `http://${url.host}`,
+        };
+    }
+    const modelName = decodeURIComponent(`${url.hostname}${url.pathname}`.replace(/^\/+/, ""));
+    if (!modelName) {
+        throw new RuntimeError(`${protocol} URI must include a model name`);
+    }
+    return { protocol, model: modelName };
+}

package/dist/providers/memory/file.js

@@ -0,0 +1,44 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { RuntimeError } from "../../runtime/errors.js";
+import { createMemoryEnvelope, isMemoryEnvelope, matchesQuery, readLimit } from "./shared.js";
+export class FileMemoryBackend {
+    add(request, path) {
+        mkdirSync(dirname(path), { recursive: true });
+        const envelope = createMemoryEnvelope(request.record);
+        appendFileSync(path, `${JSON.stringify(envelope)}\n`, "utf8");
+        return envelope;
+    }
+    query(request, path) {
+        const query = request.query;
+        const limit = readLimit(query.limit);
+        if (!existsSync(path))
+            return [];
+        const records = readJsonl(path)
+            .reverse()
+            .filter((item) => matchesQuery(item.record, query));
+        return records.slice(0, limit);
+    }
+}
+function readJsonl(path) {
+    const text = readFileSync(path, "utf8");
+    const result = [];
+    const lines = text.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        if (line.trim().length === 0)
+            continue;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new RuntimeError(`Invalid memory JSONL at ${path}:${index + 1}: ${message}`);
+        }
+        if (!isMemoryEnvelope(value)) {
+            throw new RuntimeError(`Invalid memory JSONL envelope at ${path}:${index + 1}`);
+        }
+        result.push(value);
+    }
+    return result;
+}

package/dist/providers/memory/host.js

@@ -0,0 +1,66 @@
+import { isAbsolute, relative, resolve } from "node:path";
+import { RuntimeError } from "../../runtime/errors.js";
+import { isObject } from "../../runtime/guards.js";
+import { uriScheme } from "../../runtime/uri.js";
+import { FileMemoryBackend } from "./file.js";
+import { SqliteMemoryBackend } from "./sqlite.js";
+export class HostMemoryProvider {
+    options;
+    file = new FileMemoryBackend();
+    sqlite = new SqliteMemoryBackend();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async add(request) {
+        if (!isObject(request.record)) {
+            throw new RuntimeError("memory.add expects an object record");
+        }
+        return this.backend(request.uri) === "file"
+            ? this.file.add(request, this.resolveFileMemoryPath(request.uri))
+            : this.sqlite.add(request, this.resolveSqliteMemory(request.uri));
+    }
+    async query(request) {
+        if (!isObject(request.query)) {
+            throw new RuntimeError("memory.query expects an object query");
+        }
+        return this.backend(request.uri) === "file"
+            ? this.file.query(request, this.resolveFileMemoryPath(request.uri))
+            : this.sqlite.query(request, this.resolveSqliteMemory(request.uri));
+    }
+    backend(uri) {
+        if (uri.startsWith("file://"))
+            return "file";
+        if (uri.startsWith("sqlite://"))
+            return "sqlite";
+        throw new RuntimeError(`Unsupported memory URI scheme '${uriScheme(uri)}'`);
+    }
+    resolveFileMemoryPath(uri) {
+        const rawPath = decodeURIComponent(uri.slice("file://".length));
+        const path = isAbsolute(rawPath) ? rawPath : resolve(this.options.baseDir ?? process.cwd(), rawPath);
+        this.assertWithinWorkspace(path);
+        return path;
+    }
+    resolveSqliteMemory(uri) {
+        const raw = uri.slice("sqlite://".length);
+        const hashIndex = raw.indexOf("#");
+        const rawPath = hashIndex >= 0 ? raw.slice(0, hashIndex) : raw;
+        const rawNamespace = hashIndex >= 0 ? raw.slice(hashIndex + 1) : "";
+        const decoded = decodeURIComponent(rawPath);
+        const path = isAbsolute(decoded) ? decoded : resolve(this.options.baseDir ?? process.cwd(), decoded);
+        this.assertWithinWorkspace(path);
+        return {
+            path,
+            namespace: rawNamespace.length > 0 ? decodeURIComponent(rawNamespace) : "memory",
+        };
+    }
+    assertWithinWorkspace(path) {
+        const root = resolve(this.options.workspaceRoot ?? process.cwd());
+        const rel = relative(root, resolve(path));
+        if (rel.startsWith("..") || isAbsolute(rel)) {
+            throw new RuntimeError(`Memory path '${path}' is outside workspace root '${root}'`);
+        }
+    }
+}
+export function createDefaultMemoryProvider(options = {}) {
+    return new HostMemoryProvider(options);
+}

package/dist/providers/memory/index.js

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