spl-lang 0.0.0-stage → 0.1.0

package/dist/builtins.js

@@ -0,0 +1,350 @@
+import { compareValues, equals, fromJson, hasKey, isDict, isList, newDict, runtimeError, setKey, str, toJson, truthy, typeName, } from './values.js';
+function arity(name, args, min, max = min) {
+    if (args.length < min || args.length > max) {
+        const expected = min === max ? `${min}` : `${min}-${max}`;
+        throw runtimeError(`${name}() takes ${expected} argument(s) but ${args.length} were given`);
+    }
+}
+function needNumber(name, v) {
+    if (typeof v !== 'number')
+        throw runtimeError(`${name}() expects a number, got ${typeName(v)}`);
+    return v;
+}
+function needInt(name, v) {
+    const n = needNumber(name, v);
+    if (!Number.isInteger(n))
+        throw runtimeError(`${name}() expects an integer, got ${n}`);
+    return n;
+}
+function needString(name, v) {
+    if (typeof v !== 'string')
+        throw runtimeError(`${name}() expects a string, got ${typeName(v)}`);
+    return v;
+}
+function needList(name, v) {
+    if (!isList(v))
+        throw runtimeError(`${name}() expects a list, got ${typeName(v)}`);
+    return v;
+}
+/** Values that can be iterated by `for`, `list()`, `sorted()` etc. */
+export function iterate(v) {
+    if (isList(v))
+        return v;
+    if (typeof v === 'string')
+        return Array.from(v);
+    if (isDict(v))
+        return Object.keys(v);
+    throw runtimeError(`${typeName(v)} is not iterable`);
+}
+export function makeBuiltins(ctx) {
+    const fns = new Map();
+    const def = (name, call) => fns.set(name, { __fn: 'builtin', name, call });
+    def('len', (a) => {
+        arity('len', a, 1);
+        const v = a[0];
+        if (typeof v === 'string')
+            return Array.from(v).length;
+        if (isList(v))
+            return v.length;
+        if (isDict(v))
+            return Object.keys(v).length;
+        throw runtimeError(`len() does not support ${typeName(v)}`);
+    });
+    def('str', (a) => {
+        arity('str', a, 1);
+        return str(a[0]);
+    });
+    def('int', (a) => {
+        arity('int', a, 1);
+        const v = a[0];
+        if (typeof v === 'number')
+            return Math.trunc(v);
+        if (typeof v === 'boolean')
+            return v ? 1 : 0;
+        if (typeof v === 'string' && /^\s*[+-]?\d+\s*$/.test(v))
+            return Number.parseInt(v, 10);
+        throw runtimeError(`int() cannot convert ${typeof v === 'string' ? JSON.stringify(v) : typeName(v)}`);
+    });
+    def('float', (a) => {
+        arity('float', a, 1);
+        const v = a[0];
+        if (typeof v === 'number')
+            return v;
+        if (typeof v === 'boolean')
+            return v ? 1 : 0;
+        if (typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v)))
+            return Number(v);
+        throw runtimeError(`float() cannot convert ${typeof v === 'string' ? JSON.stringify(v) : typeName(v)}`);
+    });
+    def('bool', (a) => {
+        arity('bool', a, 1);
+        return truthy(a[0]);
+    });
+    def('type', (a) => {
+        arity('type', a, 1);
+        return typeName(a[0]);
+    });
+    def('list', (a) => {
+        arity('list', a, 1);
+        return [...iterate(a[0])];
+    });
+    def('range', (a) => {
+        arity('range', a, 1, 3);
+        const nums = a.map((x) => needInt('range', x));
+        const [start, stop, step] = nums.length === 1 ? [0, nums[0], 1] : [nums[0], nums[1], nums[2] ?? 1];
+        if (step === 0)
+            throw runtimeError('range() step must not be zero');
+        const out = [];
+        for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
+            out.push(i);
+            if (out.length > 10_000_000)
+                throw runtimeError('range() is too large');
+        }
+        return out;
+    });
+    def('abs', (a) => {
+        arity('abs', a, 1);
+        return Math.abs(needNumber('abs', a[0]));
+    });
+    def('round', (a) => {
+        arity('round', a, 1, 2);
+        const n = needNumber('round', a[0]);
+        if (a.length === 1) {
+            const r = Math.round(Math.abs(n));
+            const even = Math.abs(n) % 1 === 0.5 && r % 2 === 1 ? r - 1 : r;
+            return n < 0 ? -even : even;
+        }
+        const f = 10 ** needInt('round', a[1]);
+        return Math.round(n * f) / f;
+    });
+    const extremum = (name, pick) => def(name, (a) => {
+        const items = a.length === 1 ? iterate(a[0]) : a;
+        if (items.length === 0)
+            throw runtimeError(`${name}() of an empty sequence`);
+        return items.reduce((best, x) => (pick(compareValues(x, best)) ? x : best));
+    });
+    extremum('min', (c) => c < 0);
+    extremum('max', (c) => c > 0);
+    def('sum', (a) => {
+        arity('sum', a, 1);
+        return iterate(a[0]).reduce((acc, x) => acc + needNumber('sum', x), 0);
+    });
+    def('sorted', (a) => {
+        arity('sorted', a, 1, 2);
+        const out = [...iterate(a[0])].sort(compareValues);
+        return a[1] !== undefined && truthy(a[1]) ? out.reverse() : out;
+    });
+    def('reversed', (a) => {
+        arity('reversed', a, 1);
+        return [...iterate(a[0])].reverse();
+    });
+    def('enumerate', (a) => {
+        arity('enumerate', a, 1);
+        return iterate(a[0]).map((x, i) => [i, x]);
+    });
+    def('zip', (a) => {
+        if (a.length === 0)
+            return [];
+        const lists = a.map(iterate);
+        const n = Math.min(...lists.map((l) => l.length));
+        return Array.from({ length: n }, (_, i) => lists.map((l) => l[i]));
+    });
+    def('any', (a) => {
+        arity('any', a, 1);
+        return iterate(a[0]).some(truthy);
+    });
+    def('all', (a) => {
+        arity('all', a, 1);
+        return iterate(a[0]).every(truthy);
+    });
+    def('keys', (a) => {
+        arity('keys', a, 1);
+        if (!isDict(a[0]))
+            throw runtimeError(`keys() expects a dict, got ${typeName(a[0])}`);
+        return Object.keys(a[0]);
+    });
+    def('values', (a) => {
+        arity('values', a, 1);
+        if (!isDict(a[0]))
+            throw runtimeError(`values() expects a dict, got ${typeName(a[0])}`);
+        return Object.values(a[0]);
+    });
+    def('items', (a) => {
+        arity('items', a, 1);
+        if (!isDict(a[0]))
+            throw runtimeError(`items() expects a dict, got ${typeName(a[0])}`);
+        return Object.entries(a[0]);
+    });
+    def('json_parse', (a) => {
+        arity('json_parse', a, 1);
+        try {
+            return fromJson(JSON.parse(needString('json_parse', a[0])));
+        }
+        catch (e) {
+            if (e instanceof SyntaxError)
+                throw runtimeError(`json_parse(): ${e.message}`);
+            throw e;
+        }
+    });
+    def('json_stringify', (a) => {
+        arity('json_stringify', a, 1, 2);
+        const indent = a[1] === undefined ? undefined : needInt('json_stringify', a[1]);
+        return JSON.stringify(toJson(a[0]), null, indent);
+    });
+    def('log', (a) => {
+        ctx.log(a.map(str).join(' '));
+        return null;
+    });
+    return fns;
+}
+const stringMethods = {
+    upper: (s) => s.toUpperCase(),
+    lower: (s) => s.toLowerCase(),
+    strip: (s) => s.trim(),
+    lstrip: (s) => s.trimStart(),
+    rstrip: (s) => s.trimEnd(),
+    title: (s) => s.toLowerCase().replace(/(^|\s)\S/g, (m) => m.toUpperCase()),
+    capitalize: (s) => (s ? s[0].toUpperCase() + s.slice(1).toLowerCase() : s),
+    isdigit: (s) => /^\d+$/.test(s),
+    split: (s, a) => {
+        arity('split', a, 0, 1);
+        if (a.length === 0 || a[0] === null)
+            return s.trim() === '' ? [] : s.trim().split(/\s+/);
+        const sep = needString('split', a[0]);
+        if (sep === '')
+            throw runtimeError('split() separator must not be empty');
+        return s.split(sep);
+    },
+    splitlines: (s) => (s === '' ? [] : s.split(/\r?\n/)),
+    join: (s, a) => {
+        arity('join', a, 1);
+        return iterate(a[0]).map((x) => {
+            if (typeof x !== 'string')
+                throw runtimeError(`join() expects strings, got ${typeName(x)}`);
+            return x;
+        }).join(s);
+    },
+    replace: (s, a) => {
+        arity('replace', a, 2);
+        return s.split(needString('replace', a[0])).join(needString('replace', a[1]));
+    },
+    startswith: (s, a) => {
+        arity('startswith', a, 1);
+        return s.startsWith(needString('startswith', a[0]));
+    },
+    endswith: (s, a) => {
+        arity('endswith', a, 1);
+        return s.endsWith(needString('endswith', a[0]));
+    },
+    find: (s, a) => {
+        arity('find', a, 1);
+        return s.indexOf(needString('find', a[0]));
+    },
+    count: (s, a) => {
+        arity('count', a, 1);
+        const sub = needString('count', a[0]);
+        return sub === '' ? s.length + 1 : s.split(sub).length - 1;
+    },
+};
+const listMethods = {
+    append: (l, a) => {
+        arity('append', a, 1);
+        l.push(a[0]);
+        return null;
+    },
+    extend: (l, a) => {
+        arity('extend', a, 1);
+        l.push(...iterate(a[0]));
+        return null;
+    },
+    insert: (l, a) => {
+        arity('insert', a, 2);
+        l.splice(needInt('insert', a[0]), 0, a[1]);
+        return null;
+    },
+    pop: (l, a) => {
+        arity('pop', a, 0, 1);
+        if (l.length === 0)
+            throw runtimeError('pop() from an empty list');
+        const i = a.length ? needInt('pop', a[0]) : -1;
+        const idx = i < 0 ? l.length + i : i;
+        if (idx < 0 || idx >= l.length)
+            throw runtimeError('pop() index out of range');
+        return l.splice(idx, 1)[0];
+    },
+    remove: (l, a) => {
+        arity('remove', a, 1);
+        const i = l.findIndex((x) => equals(x, a[0]));
+        if (i < 0)
+            throw runtimeError('remove(): value not in list');
+        l.splice(i, 1);
+        return null;
+    },
+    index: (l, a) => {
+        arity('index', a, 1);
+        return l.findIndex((x) => equals(x, a[0]));
+    },
+    count: (l, a) => {
+        arity('count', a, 1);
+        return l.filter((x) => equals(x, a[0])).length;
+    },
+    reverse: (l) => {
+        l.reverse();
+        return null;
+    },
+    sort: (l, a) => {
+        arity('sort', a, 0, 1);
+        l.sort(compareValues);
+        if (a.length && truthy(a[0]))
+            l.reverse();
+        return null;
+    },
+    copy: (l) => [...l],
+    clear: (l) => {
+        l.length = 0;
+        return null;
+    },
+};
+const dictMethods = {
+    keys: (d) => Object.keys(d),
+    values: (d) => Object.values(d),
+    items: (d) => Object.entries(d),
+    get: (d, a) => {
+        arity('get', a, 1, 2);
+        const k = needString('get', a[0]);
+        return hasKey(d, k) ? d[k] : (a[1] ?? null);
+    },
+    pop: (d, a) => {
+        arity('pop', a, 1, 2);
+        const k = needString('pop', a[0]);
+        if (!hasKey(d, k)) {
+            if (a.length === 2)
+                return a[1];
+            throw runtimeError(`key '${k}' not found`);
+        }
+        const v = d[k];
+        delete d[k];
+        return v;
+    },
+    update: (d, a) => {
+        arity('update', a, 1);
+        if (!isDict(a[0]))
+            throw runtimeError(`update() expects a dict, got ${typeName(a[0])}`);
+        for (const [k, v] of Object.entries(a[0]))
+            setKey(d, k, v);
+        return null;
+    },
+    copy: (d) => newDict(Object.entries(d)),
+    clear: (d) => {
+        for (const k of Object.keys(d))
+            delete d[k];
+        return null;
+    },
+};
+export function callMethod(self, name, args) {
+    const table = typeof self === 'string' ? stringMethods : isList(self) ? listMethods : isDict(self) ? dictMethods : undefined;
+    if (!table || !Object.prototype.hasOwnProperty.call(table, name)) {
+        throw runtimeError(`${typeName(self)} has no method '${name}'`);
+    }
+    return table[name](self, args);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parseArgs } from 'node:util';
+import { CopilotBackend } from './copilot.js';
+import { AuthError, login, logout } from './auth.js';
+import { SplSyntaxError } from './errors.js';
+import { Logger } from './logger.js';
+import { parse } from './parser.js';
+import { run } from './interpreter.js';
+import { JsonFileStore, MemoryStore, loadStoreModule } from './store.js';
+import { toJson } from './values.js';
+const HELP = `spl - Semantic Prompt Language interpreter
+
+Usage: spl <script.spl> [options]
+       spl login               authenticate with GitHub Copilot (device flow in the browser)
+       spl logout              remove the credentials saved by 'spl login'
+
+Options:
+  --log-level <level>     error | info | debug (default: info). Logs go to stderr.
+  --silent                suppress all logs; only the result is printed
+  --model <id>            model override (takes precedence over @{model=...})
+  --store <file.json>     persist top-level variables in a JSON file
+  --store-module <path>   custom variable store: module exporting createStore() -> { load(), save(vars) }
+  --timeout <seconds>     per LLM call timeout (default: 300)
+  --cwd <dir>             base directory for relative paths and restrictions (default: current directory)
+  --check                 parse the script and exit
+  -v, --version           print version
+  -h, --help              print this help
+
+The script result (the value of 'success' or 'return', or the failure payload) is written to stdout.
+Exit codes: 0 success, 1 uncaught script failure, 2 syntax or usage error.`;
+function version() {
+    const pkg = new URL('../package.json', import.meta.url);
+    return JSON.parse(fs.readFileSync(pkg, 'utf8')).version;
+}
+function usageError(msg) {
+    process.stderr.write(`spl: ${msg}\nTry 'spl --help'.\n`);
+    process.exit(2);
+}
+async function loginCommand() {
+    try {
+        const status = await login((line) => process.stdout.write(line + '\n'));
+        process.stdout.write(`Authenticated with GitHub Copilot${status.login ? ` as ${status.login}` : ''}.\n`);
+        return 0;
+    }
+    catch (e) {
+        if (!(e instanceof AuthError))
+            throw e;
+        process.stderr.write(`spl: login failed: ${e.message}\n`);
+        return 1;
+    }
+}
+function logoutCommand() {
+    try {
+        process.stdout.write(logout() ? 'Saved credentials removed.\n' : 'No saved credentials.\n');
+        return 0;
+    }
+    catch (e) {
+        if (!(e instanceof AuthError))
+            throw e;
+        process.stderr.write(`spl: ${e.message}\n`);
+        return 1;
+    }
+}
+async function main() {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            allowPositionals: true,
+            options: {
+                'log-level': { type: 'string' },
+                silent: { type: 'boolean' },
+                model: { type: 'string' },
+                store: { type: 'string' },
+                'store-module': { type: 'string' },
+                timeout: { type: 'string' },
+                cwd: { type: 'string' },
+                check: { type: 'boolean' },
+                version: { type: 'boolean', short: 'v' },
+                help: { type: 'boolean', short: 'h' },
+            },
+        });
+    }
+    catch (e) {
+        return usageError(e.message);
+    }
+    const { values, positionals } = parsed;
+    if (values.help) {
+        process.stdout.write(HELP + '\n');
+        return 0;
+    }
+    if (values.version) {
+        process.stdout.write(version() + '\n');
+        return 0;
+    }
+    if (positionals[0] === 'login' || positionals[0] === 'logout') {
+        if (positionals.length !== 1)
+            usageError(`'${positionals[0]}' takes no arguments`);
+        return positionals[0] === 'login' ? loginCommand() : logoutCommand();
+    }
+    if (positionals.length !== 1)
+        usageError('expected exactly one script file');
+    const level = values['log-level'] ?? 'info';
+    if (!['error', 'info', 'debug'].includes(level))
+        usageError(`invalid --log-level '${level}'`);
+    const logger = new Logger(values.silent ? 'silent' : level);
+    const timeoutSec = Number(values.timeout ?? 300);
+    if (!Number.isFinite(timeoutSec) || timeoutSec <= 0)
+        usageError('--timeout must be a positive number');
+    if (values.store && values['store-module'])
+        usageError('--store and --store-module are mutually exclusive');
+    const cwd = path.resolve(values.cwd ?? process.cwd());
+    const file = positionals[0];
+    let source;
+    try {
+        source = fs.readFileSync(file, 'utf8');
+    }
+    catch (e) {
+        return usageError(`cannot read '${file}': ${e.message}`);
+    }
+    let program;
+    try {
+        program = parse(source);
+    }
+    catch (e) {
+        if (e instanceof SplSyntaxError) {
+            process.stderr.write(e.format(file) + '\n');
+            return 2;
+        }
+        throw e;
+    }
+    if (values.check)
+        return 0;
+    let store;
+    try {
+        store = values.store ? new JsonFileStore(values.store) : values['store-module'] ? await loadStoreModule(values['store-module']) : new MemoryStore();
+    }
+    catch (e) {
+        return usageError(e.message);
+    }
+    const backend = new CopilotBackend({ logger, cwd, timeoutMs: timeoutSec * 1000 });
+    try {
+        const result = await run(program, { backend, logger, store, cwd, model: values.model });
+        if (result.status === 'failure') {
+            process.stdout.write(JSON.stringify(result.failure, null, 4) + '\n');
+            return 1;
+        }
+        if (result.hasValue) {
+            const v = result.value;
+            process.stdout.write((typeof v === 'string' ? v : JSON.stringify(toJson(v), null, 2)) + '\n');
+        }
+        return 0;
+    }
+    finally {
+        await backend.close();
+    }
+}
+main().then((code) => process.exit(code), (e) => {
+    process.stderr.write(`spl: internal error: ${e.stack ?? e}\n`);
+    process.exit(70);
+});

package/dist/copilot.d.ts

@@ -0,0 +1,29 @@
+import type { PermissionRequest, PermissionRequestResult } from '@github/copilot-sdk';
+import { Failure } from './errors.js';
+import { type LlmBackend, type LlmRequest, type LlmResponse } from './llm.js';
+import type { Logger } from './logger.js';
+import type { Restrictions } from './restrict.js';
+export interface CopilotBackendOptions {
+    logger: Logger;
+    cwd: string;
+    timeoutMs: number;
+}
+export declare class CopilotBackend implements LlmBackend {
+    private readonly opts;
+    private client?;
+    private models?;
+    constructor(opts: CopilotBackendOptions);
+    private getClient;
+    private listModels;
+    /** Maps the `think` level to the SDK reasoning effort, warning when the model cannot honor it. */
+    private resolveEffort;
+    /** Fails on a model id the runtime does not offer; it would otherwise silently fall back to the default model. */
+    private checkModel;
+    call(req: LlmRequest): Promise<LlmResponse>;
+    close(): Promise<void>;
+}
+/**
+ * Hard enforcement at the permission layer. Only the five runtime tools are exposed to the model, so any
+ * other request is denied; requests that would violate a restriction are additionally reported as violations.
+ */
+export declare function decidePermission(r: PermissionRequest, restrictions: Restrictions, block: (f: Failure) => void): PermissionRequestResult;