@flexiberry/berrycore 0.1.0

package/dist/script/postman.util.js

@@ -0,0 +1,176 @@
+import * as fs from "fs";
+export class PostmanUtil {
+    /**
+     * Convert a Postman collection file (JSON) to Berry API code
+     * @param filePath Path to the Postman collection JSON file
+     */
+    static convertFromPostmanFile(filePath) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch (e) {
+            throw new Error(`Failed to read file: ${e}`);
+        }
+        let collection;
+        try {
+            collection = JSON.parse(content);
+        }
+        catch (e) {
+            throw new Error(`Invalid JSON in Postman file`);
+        }
+        if (!collection.item) {
+            throw new Error("No items found in Postman collection");
+        }
+        const lines = [];
+        // Recursively process items
+        this.processItems(collection.item, lines);
+        return lines.join("\n").trim() + "\n";
+    }
+    /**
+     * Internal recursive processor for Postman items
+     */
+    static processItems(items, lines, parentName = "") {
+        for (const item of items) {
+            if (item.item) {
+                // It's a folder/group
+                this.processItems(item.item, lines, item.name);
+                continue;
+            }
+            if (!item.request)
+                continue;
+            const req = item.request;
+            const name = item.name || parentName || "api";
+            const method = (req.method || "GET").toUpperCase();
+            // 1. URL Resolution
+            let url = this.buildUrl(req.url);
+            // Replace postman path params :param with berry {{param}}
+            url = url.replace(/\/:([a-zA-Z0-9_]+)/g, "/{{$1}}");
+            // 2. ID Generation (Abbreviation)
+            const apiId = this.abbreviate(name);
+            // 3. Construct Berry Block
+            lines.push(`Api ${method} #${apiId} ${name}`);
+            lines.push(`Url ${url}`);
+            // 4. Headers
+            const headers = this.extractHeaders(req.header);
+            if (headers.length > 0) {
+                lines.push("Header");
+                for (const h of headers) {
+                    lines.push(`- ${h}`);
+                }
+            }
+            // 5. Body
+            const bodyContent = this.extractBody(req.body);
+            if (bodyContent) {
+                const bodyType = this.detectBodyType(req.header, req.body);
+                // Clean body to single line for preview-style import or preserve formatting?
+                // Let's preserve formatting if it's multiple lines
+                if (bodyContent.includes("\n")) {
+                    lines.push(`Body ${bodyType} \`${bodyContent.trim()}\``);
+                }
+                else {
+                    lines.push(`Body ${bodyType} \`${bodyContent}\``);
+                }
+            }
+            lines.push(""); // Spacer
+        }
+    }
+    /**
+     * Build URL string from Postman URL object
+     */
+    static buildUrl(url) {
+        if (typeof url === "string")
+            return url;
+        if (!url)
+            return "";
+        if (url.raw)
+            return url.raw;
+        if (url.host) {
+            const protocol = url.protocol || "https";
+            const host = url.host.join(".");
+            const path = url.path ? "/" + url.path.join("/") : "";
+            let fullUrl = `${protocol}://${host}${path}`;
+            if (url.query && url.query.length > 0) {
+                const queryParams = url.query
+                    .filter((q) => q.key)
+                    .map((q) => `${q.key}={{${q.key}}}`)
+                    .join("&");
+                fullUrl += `?${queryParams}`;
+            }
+            return fullUrl;
+        }
+        return "";
+    }
+    /**
+     * Abbreviate title to camelCase ID
+     */
+    static abbreviate(title) {
+        const stopWords = new Set(["a", "in", "the", "with", "and", "of", "to", "for", "on", "at", "by", "is", "it"]);
+        return title
+            .toLowerCase()
+            .replace(/[^a-z0-9 ]/g, "") // Remove special chars
+            .split(" ")
+            .filter((word) => word.length > 0 && !stopWords.has(word))
+            .map((word, index) => (index === 0 ? word : word[0].toUpperCase() + word.slice(1)))
+            .join("");
+    }
+    /**
+     * Extract headers to Berry format
+     */
+    static extractHeaders(headers) {
+        if (!headers || !Array.isArray(headers))
+            return [];
+        return headers
+            .filter((h) => h.key && h.value !== undefined)
+            .map((h) => `${h.key.trim()}: '${h.value.trim()}'`);
+    }
+    /**
+     * Extract body content from Postman request
+     */
+    static extractBody(body) {
+        if (!body || !body.mode)
+            return "";
+        switch (body.mode) {
+            case "raw":
+                return body.raw || "";
+            case "urlencoded":
+                if (body.urlencoded) {
+                    const obj = {};
+                    body.urlencoded.forEach((kv) => (obj[kv.key] = kv.value));
+                    return JSON.stringify(obj, null, 2);
+                }
+                break;
+            case "formdata":
+                if (body.formdata) {
+                    const obj = {};
+                    body.formdata.forEach((kv) => (obj[kv.key] = kv.value));
+                    return JSON.stringify(obj, null, 2);
+                }
+                break;
+            case "graphql":
+                // Postman stores graphql in a specific way, but we'll treat as raw for now
+                return body.raw || "";
+        }
+        return "";
+    }
+    /**
+     * Detect Berry body type from content-type or Postman options
+     */
+    static detectBodyType(headers, body) {
+        if (body?.options?.raw?.language) {
+            const lang = body.options.raw.language.toUpperCase();
+            if (["JSON", "XML"].includes(lang))
+                return lang;
+        }
+        const contentType = headers?.find((h) => h.key.toLowerCase() === "content-type")?.value.toLowerCase() || "";
+        if (contentType.includes("json"))
+            return "JSON";
+        if (contentType.includes("xml"))
+            return "XML";
+        if (contentType.includes("form"))
+            return "FORM";
+        if (contentType.includes("octet-stream"))
+            return "BINARY";
+        return "RAW";
+    }
+}

package/dist/script/swagger.util.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Swagger / OpenAPI Utility
+ *
+ * Utilities for converting Swagger/OpenAPI definitions to Berry code.
+ */
+export interface OpenApiSchema {
+    type?: string;
+    properties?: Record<string, OpenApiSchema>;
+    items?: OpenApiSchema;
+    $ref?: string;
+    example?: any;
+    default?: any;
+}
+export interface OpenApiParameter {
+    name: string;
+    in: "path" | "query" | "header" | "body";
+    required?: boolean;
+    schema?: OpenApiSchema;
+    example?: any;
+    default?: any;
+}
+export interface OpenApiOperation {
+    operationId?: string;
+    summary?: string;
+    parameters?: OpenApiParameter[];
+    requestBody?: {
+        content: Record<string, {
+            schema: OpenApiSchema;
+            example?: any;
+        }>;
+    };
+    consumes?: string[];
+    produces?: string[];
+}
+export interface OpenApiDefinition {
+    openapi?: string;
+    swagger?: string;
+    host?: string;
+    basePath?: string;
+    schemes?: string[];
+    servers?: Array<{
+        url: string;
+    }>;
+    paths: Record<string, Record<string, OpenApiOperation>>;
+    components?: {
+        schemas: Record<string, OpenApiSchema>;
+    };
+    definitions?: Record<string, OpenApiSchema>;
+}
+export declare class SwaggerUtil {
+    /**
+     * Fetch a Swagger/OpenAPI doc from a URL and convert it to Berry code
+     */
+    static convertFromSwaggerApi(url: string): Promise<string>;
+    /**
+     * Convert a Swagger/OpenAPI JSON string to Berry code
+     */
+    static convertSwaggerToBerry(swagger: string | OpenApiDefinition, id: string): string;
+    /**
+     * Replace {param} with {{param}} and extract query params
+     */
+    private static handlePathParams;
+    /**
+     * Build the full URL
+     */
+    private static buildUrl;
+    /**
+     * Extract headers from operation details
+     */
+    private static extractHeaders;
+    /**
+     * Generate the Body JSON block
+     */
+    private static generateBodyBlock;
+    private static mapContentTypeToBodyType;
+    /**
+     * Recursively generate dummy data from an OpenAPI schema
+     */
+    private static generateDummy;
+}

package/dist/script/swagger.util.js

@@ -0,0 +1,202 @@
+/**
+ * Swagger / OpenAPI Utility
+ *
+ * Utilities for converting Swagger/OpenAPI definitions to Berry code.
+ */
+export class SwaggerUtil {
+    /**
+     * Fetch a Swagger/OpenAPI doc from a URL and convert it to Berry code
+     */
+    static async convertFromSwaggerApi(url) {
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                return `Failed to fetch Swagger: ${response.status} ${response.statusText}`;
+            }
+            const swaggerJson = await response.text();
+            const id = url.split("/").pop() || "api";
+            return this.convertSwaggerToBerry(swaggerJson, id);
+        }
+        catch (e) {
+            return `Error fetching Swagger: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+    /**
+     * Convert a Swagger/OpenAPI JSON string to Berry code
+     */
+    static convertSwaggerToBerry(swagger, id) {
+        let obj;
+        try {
+            obj = typeof swagger === "string" ? JSON.parse(swagger) : swagger;
+        }
+        catch (e) {
+            return `Invalid Swagger/OpenAPI JSON`;
+        }
+        if (!obj.paths)
+            return "No paths found in Swagger definition";
+        const lines = [];
+        const serverUrl = obj.servers?.[0]?.url || "";
+        const schemas = obj.components?.schemas || obj.definitions || {};
+        let apiCount = 1;
+        for (const [path, methods] of Object.entries(obj.paths)) {
+            if (!methods)
+                continue;
+            for (const [method, details] of Object.entries(methods)) {
+                if (typeof details !== "object")
+                    continue;
+                const opId = details.operationId || `${id}${apiCount}`;
+                const { modPath, queryParams } = this.handlePathParams(path, details.parameters || []);
+                const finalUrl = this.buildUrl(modPath, serverUrl, obj, queryParams);
+                const headers = this.extractHeaders(details);
+                const bodyBlock = this.generateBodyBlock(details, schemas);
+                // ── Construct API Block ──
+                lines.push(`Api ${method.toUpperCase()} #${opId} ${details.summary || ""}`);
+                lines.push(`Url ${finalUrl}`);
+                if (headers.length > 0) {
+                    lines.push("Header");
+                    for (const h of headers)
+                        lines.push(`- ${h}`);
+                }
+                if (bodyBlock)
+                    lines.push(bodyBlock);
+                lines.push(""); // Spacer
+                apiCount++;
+            }
+        }
+        return lines.join("\n").trim() + "\n";
+    }
+    /**
+     * Replace {param} with {{param}} and extract query params
+     */
+    static handlePathParams(path, params) {
+        let modPath = path;
+        const queryParams = [];
+        for (const param of params) {
+            if (param.in === "path") {
+                modPath = modPath.replace(new RegExp(`{${param.name}}`, "g"), `{{${param.name}}}`);
+            }
+            else if (param.in === "query") {
+                queryParams.push(`${param.name}={{${param.name}}}`);
+            }
+        }
+        return { modPath, queryParams };
+    }
+    /**
+     * Build the full URL
+     */
+    static buildUrl(modPath, serverUrl, obj, queryParams) {
+        let url = modPath;
+        if (serverUrl) {
+            url = serverUrl.endsWith("/") && modPath.startsWith("/") ? serverUrl + modPath.slice(1) : serverUrl + modPath;
+        }
+        else if (obj.host) {
+            const scheme = obj.schemes?.[0] || "https";
+            const base = obj.basePath || "";
+            url = `${scheme}://${obj.host}${base}${modPath}`;
+        }
+        if (queryParams.length > 0) {
+            url += (url.includes("?") ? "&" : "?") + queryParams.join("&");
+        }
+        return url;
+    }
+    /**
+     * Extract headers from operation details
+     */
+    static extractHeaders(details) {
+        const headers = [];
+        // Content-Type
+        if (details.consumes?.[0]) {
+            headers.push(`Content-Type: '${details.consumes[0]}'`);
+        }
+        else if (details.requestBody?.content) {
+            const types = Object.keys(details.requestBody.content);
+            if (types[0])
+                headers.push(`Content-Type: '${types[0]}'`);
+        }
+        // Accept
+        if (details.produces?.[0]) {
+            headers.push(`Accept: '${details.produces[0]}'`);
+        }
+        // Custom headers from parameters
+        if (details.parameters) {
+            for (const p of details.parameters) {
+                if (p.in === "header") {
+                    headers.push(`${p.name}: '${p.example || p.default || ""}'`);
+                }
+            }
+        }
+        return headers;
+    }
+    /**
+     * Generate the Body JSON block
+     */
+    static generateBodyBlock(details, schemas) {
+        // OpenAPI 3
+        if (details.requestBody?.content) {
+            const content = details.requestBody.content;
+            for (const [ctype, cval] of Object.entries(content)) {
+                const dummy = cval.example || this.generateDummy(cval.schema, schemas);
+                const bodyType = this.mapContentTypeToBodyType(ctype);
+                return `Body ${bodyType} \`${JSON.stringify(dummy, null, 2)}\``;
+            }
+        }
+        // Swagger 2
+        if (details.parameters) {
+            const bodyParam = details.parameters.find((p) => p.in === "body");
+            if (bodyParam?.schema) {
+                const dummy = this.generateDummy(bodyParam.schema, schemas);
+                return `Body JSON \`${JSON.stringify(dummy, null, 2)}\``;
+            }
+        }
+        return "";
+    }
+    static mapContentTypeToBodyType(ctype) {
+        const ct = ctype.toLowerCase();
+        if (ct.includes("json"))
+            return "JSON";
+        if (ct.includes("xml"))
+            return "XML";
+        if (ct.includes("form"))
+            return "FORM";
+        if (ct.includes("octet-stream"))
+            return "BINARY";
+        return "RAW";
+    }
+    /**
+     * Recursively generate dummy data from an OpenAPI schema
+     */
+    static generateDummy(schema, schemas, depth = 0) {
+        if (!schema || depth > 5)
+            return {};
+        if (schema.example !== undefined)
+            return schema.example;
+        if (schema.default !== undefined)
+            return schema.default;
+        if (schema.$ref) {
+            const refName = schema.$ref.replace(/^#\/(definitions|components\/schemas)\//, "");
+            const resolved = schemas[refName];
+            return resolved ? this.generateDummy(resolved, schemas, depth + 1) : {};
+        }
+        switch (schema.type) {
+            case "string":
+                return "string";
+            case "integer":
+            case "number":
+                return 0;
+            case "boolean":
+                return false;
+            case "array":
+                return schema.items ? [this.generateDummy(schema.items, schemas, depth + 1)] : [];
+            case "object":
+            default:
+                if (schema.properties) {
+                    const obj = {};
+                    for (const [key, prop] of Object.entries(schema.properties)) {
+                        obj[key] = this.generateDummy(prop, schemas, depth + 1);
+                    }
+                    return obj;
+                }
+                return {};
+        }
+    }
+}

package/dist/util/store-util.d.ts

@@ -0,0 +1,5 @@
+export declare class StoreUtility {
+    systemDocumentFolder: string;
+    static storeData(data: Record<string, any>, fileName: string): Promise<void>;
+    static retriveData(fileName: string): Promise<void>;
+}

package/dist/util/store-util.js

@@ -0,0 +1,22 @@
+import * as fs from "fs";
+import os from "os";
+import path from "path";
+export class StoreUtility {
+    systemDocumentFolder = path.join(os.homedir(), "Documents");
+    static async storeData(data, fileName) {
+        const fileContent = Object.entries(data)
+            .map(([key, value]) => `${key}:${value}`)
+            .join("\n");
+        fs.writeFileSync(fileName, fileContent);
+    }
+    static async retriveData(fileName) {
+        const fileData = fs.readFileSync(fileName, "utf8");
+        const keyValueMap = {};
+        fileData.split("\n").forEach((line) => {
+            const [key, value] = line.split(":");
+            if (key && value) {
+                keyValueMap[key.trim()] = value.trim();
+            }
+        });
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@flexiberry/berrycore",
+  "version": "0.1.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "type": "module",
+  "bin": {
+    "berrycore": "./dist/index.js"
+  },
+  "keywords": [],
+  "author": "rintu raj c",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsc && node scripts/fix-esm.mjs",
+    "watch": "tsc --watch",
+    "clean": "rm -rf dist"
+  }
+}

package/readme.md

@@ -0,0 +1,107 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/Flexiberry/flexiberry/main/assets/favicon/android-icon-192x192.png" height="120" width="120" alt="FlexiBerry Logo" />
+  <h1>🚀 @flexiberry/berrycore</h1>
+  <p><strong>The official Lexer, Parser, AST, and Runtime Engine for the Berry DSL</strong></p>
+
+  [![npm version](https://img.shields.io/npm/v/@flexiberry/berrycore.svg?style=flat-square)](https://www.npmjs.com/package/@flexiberry/berrycore)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+
+  <br />
+</div>
+
+## ✨ Overview
+
+**BerryCore** is a lightweight, zero-dependency compiler architecture built entirely in TypeScript. It provides the foundational tools required to interpret the **Berry DSL** (Domain Specific Language), a custom scripting language explicitly designed to orchestrate API flows, manage testing environments, and execute complex task runners.
+
+This package exposes the complete language engineering pipeline:
+1. **LexerEngine** - Scans characters and generates grammar-aware tokens.
+2. **AstEngine** - Parses tokens into a strongly-typed Abstract Syntax Tree (AST).
+3. **Interpreter** - The runtime execution engine that evaluates the AST, manages isolated environment scopes, and fires runtime events.
+4. **Formatter** - Converts the AST back into cleanly formatted `.berry` script.
+
+---
+
+## 📦 Installation
+
+Install `@flexiberry/berrycore` as a core dependency for your own test runners, CI pipelines, or editor integrations:
+
+```bash
+npm install @flexiberry/berrycore
+```
+
+---
+
+## 🛠️ Programmatic Usage
+
+The core engine is heavily decoupled, allowing you to use just the parts you need—whether you are building a language server, an IDE, or a CLI.
+
+
+## 📖 Language Syntax Reference
+
+The Berry DSL was designed to be easily readable, removing complex syntax clutter in favor of a clean, indentation-aware syntax. 
+
+### 1. Environments (`Env`)
+Defines the deployment environments available for the script.
+```berry
+Env UAT, SIT, PROD
+```
+
+### 2. Variables (`Var`)
+Isolated memory scopes for storing state. Variables are initialized directly in the runtime environment.
+```berry
+Var UserData
+- id: 101
+- name: "John Doe"
+```
+
+### 3. API Declarations (`Api`)
+Defines HTTP endpoints with strict schema definitions.
+```berry
+Api POST #CreateUser "Creates a new user"
+Url 'https://api.example.com/users'
+Body JSON
+`{
+  "name": "{{UserData.name}}"
+}`
+Header
+- Authorization: 'Bearer {{token}}'
+```
+
+### 4. Tasks and Steps (`Task` / `Step`)
+The execution blocks where the interpreter orchestrates logic.
+```berry
+Task "User Onboarding"
+  Step "Register New User"
+    Call #CreateUser
+    Capture
+    - token: "response.data.token"
+    Check
+    - status == 201
+```
+
+### 5. Control Flow (`Jump`, `Break`)
+The interpreter supports localized control flow within Tasks.
+```berry
+Break if status == 400
+Jump To @2 If status == 401
+```
+
+---
+
+## 🧠 Architectural Principles
+
+Following standard language engineering practices, `berrycore` adheres strictly to:
+- **Separation of Concerns:** The parser never executes code. The interpreter never scans tokens.
+- **Type Safety:** All AST nodes are backed by strict TypeScript interfaces (`BaseNode`, `TaskBlockNode`, etc.).
+- **Immutability:** The AST generated by `AstEngine` is treated as a pure, immutable data layer.
+- **Event-Driven Execution:** The `Interpreter` engine acts as an event emitter, allowing external UI layers (like CLI spinners or web dashboards) to hook directly into the runtime state.
+
+---
+
+## 🤝 Contributing
+
+This package is part of the FlexiBerry monorepo. We welcome contributions to grammar definitions, execution optimizations, and AST tooling. Please see the root `CONTRIBUTING.md` for guidelines.
+
+## 📄 License
+
+MIT © FlexiBerry.dev