@flexiberry/berrycore 0.1.0

package/dist/interpreter/interpreter.types.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Interpreter Types
+ *
+ * Runtime value types, execution status, event types,
+ * and the IOAdapter interface for CLI/UI input abstraction.
+ */
+/** Any value that can exist at runtime */
+export type RuntimeValue = string | number | boolean | Record<string, unknown> | null;
+export declare enum ExecutionStatus {
+    Pending = "PENDING",
+    Running = "RUNNING",
+    Pass = "PASS",
+    Failed = "FAILED",
+    Skipped = "SKIPPED",
+    Paused = "PAUSED",
+    Stopped = "STOPPED",
+    Killed = "KILLED"
+}
+export declare enum InterpreterEvent {
+    /** Interpreter has started execution */
+    Start = "START",
+    /** Interpreter has completed all tasks */
+    Completed = "COMPLETED",
+    /** A task is about to begin */
+    TaskBegin = "TASK_BEGIN",
+    /** A task has finished */
+    TaskDone = "TASK_DONE",
+    /** A step is about to begin */
+    StepBegin = "STEP_BEGIN",
+    /** A step has finished */
+    StepDone = "STEP_DONE",
+    /** An API call is about to be made */
+    ApiCallBegin = "API_CALL_BEGIN",
+    /** An API call has completed */
+    ApiCallDone = "API_CALL_DONE",
+    /** General log message */
+    Log = "LOG",
+    /** Runtime error occurred */
+    Error = "ERROR",
+    /** Interpreter requires user input */
+    InputRequired = "INPUT_REQUIRED",
+    /** Execution state changed (paused, resumed, killed) */
+    StateChanged = "STATE_CHANGED",
+    /** Data from an Input statement has been loaded */
+    DataLoaded = "DATA_LOADED"
+}
+export interface StartPayload {
+    readonly totalTasks: number;
+    readonly totalApis: number;
+    readonly totalVars: number;
+    readonly startTime: Date;
+    readonly plan: ReadonlyArray<{
+        readonly title: string | null;
+        readonly steps: ReadonlyArray<{
+            readonly targetName: string;
+        }>;
+    }>;
+}
+export interface CompletedPayload {
+    readonly endTime: Date;
+    readonly taskResults: readonly TaskResult[];
+}
+export interface TaskResult {
+    readonly title: string | null;
+    readonly status: ExecutionStatus;
+    readonly startTime: Date;
+    readonly endTime: Date;
+    readonly steps: readonly StepResult[];
+}
+export interface StepResult {
+    readonly targetName: string;
+    readonly status: ExecutionStatus;
+    readonly startTime: Date;
+    readonly endTime: Date;
+    readonly error: string | null;
+    readonly response: ApiResponse | null;
+    readonly checksPassed: boolean | null;
+}
+export interface ApiResponse {
+    readonly status: number;
+    readonly headers: Record<string, string>;
+    readonly body: unknown;
+}
+export interface LogPayload {
+    readonly level: "info" | "warn" | "debug";
+    readonly message: string;
+}
+export interface ErrorPayload {
+    readonly message: string;
+    readonly line?: number;
+    readonly column?: number;
+}
+export type EventPayloadMap = {
+    [InterpreterEvent.Start]: StartPayload;
+    [InterpreterEvent.Completed]: CompletedPayload;
+    [InterpreterEvent.TaskBegin]: {
+        readonly title: string | null;
+        readonly index: number;
+    };
+    [InterpreterEvent.TaskDone]: TaskResult;
+    [InterpreterEvent.StepBegin]: {
+        readonly targetName: string;
+        readonly index: number;
+        readonly taskIndex: number;
+    };
+    [InterpreterEvent.StepDone]: StepResult & {
+        readonly taskIndex: number;
+        readonly index: number;
+    };
+    [InterpreterEvent.ApiCallBegin]: {
+        readonly method: string;
+        readonly url: string;
+        readonly apiName: string;
+    };
+    [InterpreterEvent.ApiCallDone]: {
+        readonly apiName: string;
+        readonly status: number;
+        readonly duration: number;
+    };
+    [InterpreterEvent.Log]: LogPayload;
+    [InterpreterEvent.Error]: ErrorPayload;
+    [InterpreterEvent.InputRequired]: {
+        readonly prompt: string;
+    };
+    [InterpreterEvent.StateChanged]: {
+        readonly state: ExecutionState;
+        readonly reason: string;
+    };
+    [InterpreterEvent.DataLoaded]: {
+        readonly rows: Record<string, string>[];
+    };
+};
+export type EventListener<E extends InterpreterEvent> = (payload: EventPayloadMap[E]) => void | Promise<void>;
+export type LogLevel = "info" | "warn" | "error" | "debug" | "step" | "task" | "api";
+/** Commands that can be sent to the interpreter at any time */
+export declare enum ExecutionCommand {
+    /** Continue to the next step (default behavior) */
+    Continue = "CONTINUE",
+    /** Skip the current/next step and move on */
+    Skip = "SKIP",
+    /** Stop the current task (skip remaining steps) and move to next task */
+    Stop = "STOP",
+    /** Pause execution — wait for Continue or Kill */
+    Pause = "PAUSE",
+    /** Kill execution — clean up all resources and abort immediately */
+    Kill = "KILL"
+}
+/** The current execution state of the interpreter */
+export declare enum ExecutionState {
+    Idle = "IDLE",
+    Running = "RUNNING",
+    Paused = "PAUSED",
+    Stopped = "STOPPED",
+    Killed = "KILLED",
+    Completed = "COMPLETED"
+}
+/**
+ * Abstraction for user input, output, AND execution control.
+ * Implement this for CLI (readline/stdout) or UI (callback/websocket).
+ */
+export interface IOAdapter {
+    /** Prompt the user for input and return the response */
+    prompt(message: string): Promise<string>;
+    /** Optional: confirm yes/no from user */
+    confirm?(message: string): Promise<boolean>;
+    /**
+     * Push a log line to the output.
+     * Called by the interpreter for real-time status updates.
+     */
+    log?(level: LogLevel, message: string): void;
+    /**
+     * Register a callback that the adapter calls when the user issues a command.
+     * The interpreter calls this once at startup to give the adapter
+     * a way to send commands back.
+     */
+    onCommand?(handler: (command: ExecutionCommand) => void): void;
+    /**
+     * Called when the interpreter is being killed.
+     * Adapter should clean up its resources (close readline, sockets, etc.).
+     */
+    dispose?(): void;
+}

package/dist/interpreter/interpreter.types.js

@@ -0,0 +1,73 @@
+/**
+ * Interpreter Types
+ *
+ * Runtime value types, execution status, event types,
+ * and the IOAdapter interface for CLI/UI input abstraction.
+ */
+// ─── Execution Status ───────────────────────────────────────────────────────
+export var ExecutionStatus;
+(function (ExecutionStatus) {
+    ExecutionStatus["Pending"] = "PENDING";
+    ExecutionStatus["Running"] = "RUNNING";
+    ExecutionStatus["Pass"] = "PASS";
+    ExecutionStatus["Failed"] = "FAILED";
+    ExecutionStatus["Skipped"] = "SKIPPED";
+    ExecutionStatus["Paused"] = "PAUSED";
+    ExecutionStatus["Stopped"] = "STOPPED";
+    ExecutionStatus["Killed"] = "KILLED";
+})(ExecutionStatus || (ExecutionStatus = {}));
+// ─── Interpreter Events ─────────────────────────────────────────────────────
+export var InterpreterEvent;
+(function (InterpreterEvent) {
+    /** Interpreter has started execution */
+    InterpreterEvent["Start"] = "START";
+    /** Interpreter has completed all tasks */
+    InterpreterEvent["Completed"] = "COMPLETED";
+    /** A task is about to begin */
+    InterpreterEvent["TaskBegin"] = "TASK_BEGIN";
+    /** A task has finished */
+    InterpreterEvent["TaskDone"] = "TASK_DONE";
+    /** A step is about to begin */
+    InterpreterEvent["StepBegin"] = "STEP_BEGIN";
+    /** A step has finished */
+    InterpreterEvent["StepDone"] = "STEP_DONE";
+    /** An API call is about to be made */
+    InterpreterEvent["ApiCallBegin"] = "API_CALL_BEGIN";
+    /** An API call has completed */
+    InterpreterEvent["ApiCallDone"] = "API_CALL_DONE";
+    /** General log message */
+    InterpreterEvent["Log"] = "LOG";
+    /** Runtime error occurred */
+    InterpreterEvent["Error"] = "ERROR";
+    /** Interpreter requires user input */
+    InterpreterEvent["InputRequired"] = "INPUT_REQUIRED";
+    /** Execution state changed (paused, resumed, killed) */
+    InterpreterEvent["StateChanged"] = "STATE_CHANGED";
+    /** Data from an Input statement has been loaded */
+    InterpreterEvent["DataLoaded"] = "DATA_LOADED";
+})(InterpreterEvent || (InterpreterEvent = {}));
+// ─── Execution Commands ─────────────────────────────────────────────────────
+/** Commands that can be sent to the interpreter at any time */
+export var ExecutionCommand;
+(function (ExecutionCommand) {
+    /** Continue to the next step (default behavior) */
+    ExecutionCommand["Continue"] = "CONTINUE";
+    /** Skip the current/next step and move on */
+    ExecutionCommand["Skip"] = "SKIP";
+    /** Stop the current task (skip remaining steps) and move to next task */
+    ExecutionCommand["Stop"] = "STOP";
+    /** Pause execution — wait for Continue or Kill */
+    ExecutionCommand["Pause"] = "PAUSE";
+    /** Kill execution — clean up all resources and abort immediately */
+    ExecutionCommand["Kill"] = "KILL";
+})(ExecutionCommand || (ExecutionCommand = {}));
+/** The current execution state of the interpreter */
+export var ExecutionState;
+(function (ExecutionState) {
+    ExecutionState["Idle"] = "IDLE";
+    ExecutionState["Running"] = "RUNNING";
+    ExecutionState["Paused"] = "PAUSED";
+    ExecutionState["Stopped"] = "STOPPED";
+    ExecutionState["Killed"] = "KILLED";
+    ExecutionState["Completed"] = "COMPLETED";
+})(ExecutionState || (ExecutionState = {}));

package/dist/parser/ast/ast.engine.d.ts

@@ -0,0 +1,103 @@
+/**
+ * AST Engine — Recursive Descent Parser
+ *
+ * Consumes Token[] from the LexerEngine and produces a ProgramNode AST.
+ * Each parse* method corresponds to one grammar rule from reader_v2.
+ *
+ * Architecture rules enforced:
+ *   - Parser ONLY produces AST — no runtime execution
+ *   - Deterministic recursive descent
+ *   - Throws syntax errors with line/column info
+ */
+import { Token } from "../tokenizer/token.js";
+import { ProgramNode } from "./ast.types.js";
+export declare class ParserError extends Error {
+    readonly line: number;
+    readonly column: number;
+    constructor(message: string, line: number, column: number);
+}
+export declare class Ast {
+    static parse(code: string): ProgramNode;
+}
+export declare class AstEngine {
+    private readonly tokens;
+    private cursor;
+    constructor(tokens: Token[]);
+    /** Entry point: parse entire token stream into ProgramNode */
+    build(): ProgramNode;
+    private parseStatement;
+    /**
+     * Grammar: Var ((@)(pointed) (title))? keyValueLoop
+     * Tokens:  Var, optional Pointer+Pointed+Title, then key-value pairs
+     */
+    private parseVarDeclaration;
+    private parsePointerReference;
+    /**
+     * Grammar: Link <path>
+     * Tokens:  Link, LinkPath
+     */
+    private parseLinkStatement;
+    /**
+     * Grammar: Input <path>
+     * Tokens:  Input, InputPath
+     */
+    private parseInputStatement;
+    /**
+     * Grammar: Api (GET|POST|..)? #identifier title?
+     *          Url value
+     *          Header keyValueLoop
+     *          Body type `content`
+     */
+    private parseApiBlock;
+    private parseUrlStatement;
+    private parseHeaderBlock;
+    private parseBodyBlock;
+    /**
+     * Grammar: Task title?
+     * Tokens:  Task, Title
+     */
+    private parseTaskBlock;
+    /**
+     * Grammar: Step Call Api identifier
+     * Tokens:  Step, Call, Api, Identifier
+     */
+    private parseStepBlock;
+    /**
+     * Grammar: Params keyValueLoop
+     * Tokens:  Params, then key-value pairs
+     */
+    private parseParamsBlock;
+    /**
+     * Grammar: Capture keyValueLoop
+     * Tokens:  Capture, then key-value pairs
+     */
+    private parseCaptureBlock;
+    /**
+     * Grammar: Check conditionLoop
+     * Tokens:  Check, then condition list
+     */
+    private parseCheckBlock;
+    /**
+     * Grammar: (- key: value)*
+     * Loops while Hyphen tokens appear
+     */
+    private parseKeyValuePairs;
+    /**
+     * Grammar: (- lhs operator rhs (OR lhs operator rhs)*)*
+     * Loops while Hyphen tokens appear
+     */
+    private parseConditions;
+    private parseComment;
+    /** Check if we've reached EOF */
+    private isEof;
+    /** Peek at current token without consuming */
+    private peek;
+    /** Check if current token matches expected type */
+    private check;
+    /** Consume current token and return it */
+    private advance;
+    /** Expect a specific token type or throw a ParserError */
+    private expect;
+    /** Extract NodePosition from a Token */
+    private positionOf;
+}