@flexiberry/berrycore 0.1.0

package/dist/interpreter/environment.js

@@ -0,0 +1,96 @@
+/**
+ * Environment — Scoped Variable Store
+ *
+ * Maintains a chain of scopes: global → task → step.
+ * Each scope is a Map<string, RuntimeValue>.
+ * Lookup walks up the parent chain.
+ */
+import { VariableNotFoundError } from "./errors.js";
+export class Environment {
+    store = new Map();
+    parent;
+    constructor(parent = null) {
+        this.parent = parent;
+    }
+    /**
+     * Declare a new variable in this scope.
+     * Overwrites if it already exists in this scope.
+     */
+    declare(name, value) {
+        this.store.set(name, value);
+    }
+    /**
+     * Look up a variable, walking up the scope chain.
+     * Throws VariableNotFoundError if not found in any scope.
+     */
+    lookup(name) {
+        if (this.store.has(name)) {
+            return this.store.get(name);
+        }
+        if (this.parent) {
+            return this.parent.lookup(name);
+        }
+        throw new VariableNotFoundError(name);
+    }
+    /**
+     * Try to look up a variable without throwing.
+     * Returns undefined if not found.
+     */
+    tryLookup(name) {
+        if (this.store.has(name)) {
+            return this.store.get(name);
+        }
+        if (this.parent) {
+            return this.parent.tryLookup(name);
+        }
+        return undefined;
+    }
+    /**
+     * Assign a value to an existing variable in the nearest scope.
+     * If not found, declares it in this scope.
+     */
+    assign(name, value) {
+        if (this.store.has(name)) {
+            this.store.set(name, value);
+            return;
+        }
+        if (this.parent) {
+            try {
+                this.parent.lookup(name); // check if exists in parent
+                this.parent.assign(name, value);
+                return;
+            }
+            catch {
+                // not in parent, declare locally
+            }
+        }
+        this.store.set(name, value);
+    }
+    /**
+     * Create a child scope inheriting from this environment.
+     */
+    createChild() {
+        return new Environment(this);
+    }
+    /**
+     * Get all variables in this scope (not parents).
+     */
+    getOwnEntries() {
+        return this.store;
+    }
+    /**
+     * Get all variables including parent scopes (closest wins).
+     */
+    getAllEntries() {
+        const merged = new Map();
+        if (this.parent) {
+            for (const [k, v] of this.parent.getAllEntries()) {
+                merged.set(k, v);
+            }
+        }
+        for (const [k, v] of this.store) {
+            merged.set(k, v);
+        }
+        return merged;
+    }
+}

package/dist/interpreter/errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Interpreter Errors
+ *
+ * Strongly typed error classes with source position info.
+ */
+export declare class RuntimeError extends Error {
+    readonly line: number;
+    readonly column: number;
+    constructor(message: string, line?: number, column?: number);
+}
+export declare class VariableNotFoundError extends RuntimeError {
+    constructor(name: string, line?: number, column?: number);
+}
+export declare class ApiNotFoundError extends RuntimeError {
+    constructor(name: string, line?: number, column?: number);
+}

package/dist/interpreter/errors.js

@@ -0,0 +1,27 @@
+/**
+ * Interpreter Errors
+ *
+ * Strongly typed error classes with source position info.
+ */
+export class RuntimeError extends Error {
+    line;
+    column;
+    constructor(message, line = 0, column = 0) {
+        super(`[RuntimeError at ${line}:${column}] ${message}`);
+        this.name = "RuntimeError";
+        this.line = line;
+        this.column = column;
+    }
+}
+export class VariableNotFoundError extends RuntimeError {
+    constructor(name, line = 0, column = 0) {
+        super(`Variable '${name}' is not defined`, line, column);
+        this.name = "VariableNotFoundError";
+    }
+}
+export class ApiNotFoundError extends RuntimeError {
+    constructor(name, line = 0, column = 0) {
+        super(`API '${name}' is not defined`, line, column);
+        this.name = "ApiNotFoundError";
+    }
+}

package/dist/interpreter/interpreter.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Berry Interpreter
+ *
+ * Walks the ProgramNode AST and executes the Berry program.
+ * Uses the Visitor pattern — one visit* method per AST node type.
+ *
+ * Architecture rules:
+ *   - Interpreter only walks AST — no parsing, no tokenizing
+ *   - Maintains environment for variable scoping
+ *   - Emits typed events for status reporting
+ *   - Uses IOAdapter for user input (CLI or UI)
+ */
+export interface FetchResponse {
+    readonly status: number;
+    readonly data: any;
+    readonly headers: Record<string, string>;
+}
+import { ProgramNode, KeyValuePairNode } from "../parser/ast/ast.types.js";
+import { InterpreterEvent, EventListener, ExecutionCommand, ExecutionState, IOAdapter, TaskResult } from "./interpreter.types.js";
+import { Environment } from "./environment.js";
+export interface InterpreterOptions {
+    /** Timeout in ms for API calls (default: 30000) */
+    readonly apiTimeout: number;
+    /** Whether to continue on step failure (default: true) */
+    readonly continueOnError: boolean;
+    /** Dry run — don't make actual API calls (default: false) */
+    readonly dryRun: boolean;
+    /** Injected row of data for Input statements */
+    readonly inputRow?: Record<string, string>;
+    /** Provider for decrypting encrypted variables */
+    readonly decryptionProvider?: (encrypted: string) => Promise<string> | string;
+}
+interface ApiDefinition {
+    readonly method: string;
+    readonly name: string;
+    readonly title: string | null;
+    readonly url: string | null;
+    readonly headers: ReadonlyArray<KeyValuePairNode>;
+    readonly bodyType: string | null;
+    readonly bodyContent: string | null;
+}
+export declare class Interpreter {
+    private readonly ast;
+    private readonly options;
+    private readonly globalEnv;
+    private readonly apiRegistry;
+    private readonly listeners;
+    private ioAdapter;
+    private state;
+    private pendingCommand;
+    private pauseResolver;
+    /** Check if killed — bypasses TS narrowing since state changes async */
+    private isKilled;
+    constructor(ast: ProgramNode, options?: Partial<InterpreterOptions>);
+    /** Register an event listener */
+    on<E extends InterpreterEvent>(event: E, listener: EventListener<E>): Interpreter;
+    /** Set the IO adapter for user input, output, and execution control */
+    setIOAdapter(adapter: IOAdapter): Interpreter;
+    /**
+     * Send an execution command to the interpreter.
+     * Can be called externally (from adapter, UI, or programmatically).
+     */
+    sendCommand(command: ExecutionCommand): void;
+    /** Get the current execution state */
+    getState(): ExecutionState;
+    /** Kill execution and clean up all resources */
+    kill(): void;
+    /** Execute the entire program */
+    execute(): Promise<TaskResult[]>;
+    private visitVarDeclaration;
+    private visitApiBlock;
+    private visitTask;
+    private visitStep;
+    private callApi;
+    private resolveParams;
+    private processCapture;
+    private processCheck;
+    private evaluateCondition;
+    private compareValues;
+    private resolveValue;
+    /**
+     * Resolve a dot-separated path from response data.
+     * e.g., "response.id" → data.id
+     */
+    private resolveResponsePath;
+    /**
+     * Replace {{varName}} placeholders with values from the variable map.
+     */
+    private interpolate;
+    private emit;
+    private emitSync;
+    private defaultDecryptionProvider;
+    /** Push a log line through the IO adapter (if set and supports logging) */
+    private pushLog;
+    /** Block execution while state is Paused */
+    private waitIfPaused;
+    /** Emit a state change event */
+    private emitStateChanged;
+    /**
+     * Clean up all resources.
+     * Called on kill — clears environment, registry, listeners, adapter.
+     */
+    private cleanup;
+    /** Get the global environment (for inspection/testing) */
+    getEnvironment(): Environment;
+    /** Get the API registry (for inspection/testing) */
+    getApiRegistry(): ReadonlyMap<string, ApiDefinition>;
+    /** Prompt the user for input via the IOAdapter */
+    promptUser(message: string): Promise<string>;
+}
+export {};