nava-sanskritam 1.0.0

package/Interpreter.js

@@ -0,0 +1,100 @@
+class Interpreter {
+    constructor() {
+        this.environment = new Map();
+    }
+
+    interpret(ast) {
+        if (ast.type === 'Program') {
+            for (let stmt of ast.body) {
+                this.execute(stmt);
+            }
+        } else {
+            throw new Error(`Unknown AST node type: ${ast.type}`);
+        }
+    }
+
+    execute(stmt) {
+        switch (stmt.type) {
+            case 'VariableDeclaration':
+                let val = this.evaluate(stmt.init);
+                this.environment.set(stmt.id, val);
+                break;
+            case 'PrintStatement':
+                console.log(this.evaluate(stmt.expression));
+                break;
+            case 'ExpressionStatement':
+                this.evaluate(stmt.expression);
+                break;
+            case 'IfStatement':
+                if (this.evaluate(stmt.condition)) {
+                    this.executeBlockOrStatement(stmt.consequence);
+                }
+                break;
+            case 'LoopStatement':
+                if (stmt.init) {
+                    this.evaluate(stmt.init);
+                }
+                while (stmt.test ? this.evaluate(stmt.test) : true) {
+                    this.executeBlockOrStatement(stmt.body);
+                    if (stmt.update) {
+                        this.evaluate(stmt.update);
+                    }
+                }
+                break;
+            case 'BlockStatement':
+                for (let bStmt of stmt.body) {
+                    this.execute(bStmt);
+                }
+                break;
+            default:
+                throw new Error(`Unknown statement type: ${stmt.type}`);
+        }
+    }
+
+    executeBlockOrStatement(node) {
+        if (node.type === 'BlockStatement') {
+            this.execute(node);
+        } else {
+            this.execute(node);
+        }
+    }
+
+    evaluate(expr) {
+        switch (expr.type) {
+            case 'Literal':
+                return expr.value;
+            case 'Identifier':
+                if (this.environment.has(expr.name)) {
+                    return this.environment.get(expr.name);
+                }
+                throw new Error(`Undefined variable: ${expr.name}`);
+            case 'Assignment':
+                let value = this.evaluate(expr.right);
+                // Allow assignment to implicitly declare if not present in loops, but strict generally
+                // Actually, for the loop like `i = 1`, if it's not declared with अस्ति, we should allow it as implicit declaration or simply set it.
+                this.environment.set(expr.left, value);
+                return value;
+            case 'BinaryExpression':
+                let left = this.evaluate(expr.left);
+                let right = this.evaluate(expr.right);
+                switch (expr.operator) {
+                    case '+': return left + right;
+                    case '-': return left - right;
+                    case '*': return left * right;
+                    case '/': return left / right;
+                    case '<': return left < right;
+                    case '<=': return left <= right;
+                    case '>': return left > right;
+                    case '>=': return left >= right;
+                    case '==': return left === right;
+                    case '!=': return left !== right;
+                    default:
+                        throw new Error(`Unknown operator: ${expr.operator}`);
+                }
+            default:
+                throw new Error(`Unknown expression type: ${expr.type}`);
+        }
+    }
+}
+
+module.exports = Interpreter;

package/Lexer.js

@@ -0,0 +1,154 @@
+class Lexer {
+    constructor(input) {
+        this.input = input;
+        this.pos = 0;
+        this.line = 1;
+        this.col = 1;
+        this.tokens = [];
+
+        this.keywords = new Set(['अस्ति', 'वद', 'यदि', 'तर्हि', 'चक्र']);
+        this.devanagariDigits = {
+            '०': '0', '१': '1', '२': '2', '३': '3', '४': '4',
+            '५': '5', '६': '6', '७': '7', '८': '8', '९': '9'
+        };
+    }
+
+    tokenize() {
+        while (this.pos < this.input.length) {
+            let char = this.currentChar();
+
+            if (this.isWhitespace(char)) {
+                this.advance();
+                continue;
+            }
+
+            if (this.isPunctuation(char)) {
+                this.tokens.push({ type: 'PUNCTUATION', value: char, line: this.line, col: this.col });
+                this.advance();
+                continue;
+            }
+
+            if (this.isOperatorChar(char)) {
+                let op = this.readOperator();
+                this.tokens.push({ type: 'OPERATOR', value: op, line: this.line, col: this.col });
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                let str = this.readString(char);
+                this.tokens.push({ type: 'STRING', value: str, line: this.line, col: this.col });
+                continue;
+            }
+
+            if (this.isDigit(char) || this.isDevanagariDigit(char)) {
+                let num = this.readNumber();
+                this.tokens.push({ type: 'NUMBER', value: num, line: this.line, col: this.col });
+                continue;
+            }
+
+            if (this.isIdentifierChar(char)) {
+                let id = this.readIdentifier();
+                if (this.keywords.has(id)) {
+                    this.tokens.push({ type: 'KEYWORD', value: id, line: this.line, col: this.col });
+                } else {
+                    this.tokens.push({ type: 'IDENTIFIER', value: id, line: this.line, col: this.col });
+                }
+                continue;
+            }
+
+            throw new Error(`Lexer Error: Unexpected character '${char}' at line ${this.line}, col ${this.col}`);
+        }
+
+        this.tokens.push({ type: 'EOF', value: null, line: this.line, col: this.col });
+        return this.tokens;
+    }
+
+    currentChar() {
+        return this.input[this.pos];
+    }
+
+    advance() {
+        if (this.currentChar() === '\n') {
+            this.line++;
+            this.col = 1;
+        } else {
+            this.col++;
+        }
+        this.pos++;
+    }
+
+    isWhitespace(char) {
+        return /\s/.test(char);
+    }
+
+    isPunctuation(char) {
+        return /[(){}\[\],;]/.test(char);
+    }
+
+    isOperatorChar(char) {
+        return /[=+\-*/<>!]/.test(char);
+    }
+
+    readOperator() {
+        let op = '';
+        while (this.pos < this.input.length && this.isOperatorChar(this.currentChar())) {
+            op += this.currentChar();
+            this.advance();
+        }
+        return op;
+    }
+
+    readString(quoteChar) {
+        let startLine = this.line;
+        let startCol = this.col;
+        this.advance(); // Skip opening quote
+        let str = '';
+        while (this.pos < this.input.length && this.currentChar() !== quoteChar) {
+            str += this.currentChar();
+            this.advance();
+        }
+        if (this.pos >= this.input.length) {
+            throw new Error(`Lexer Error: Unterminated string starting at line ${startLine}, col ${startCol}`);
+        }
+        this.advance(); // Skip closing quote
+        return str;
+    }
+
+    isDigit(char) {
+        return /[0-9]/.test(char);
+    }
+
+    isDevanagariDigit(char) {
+        return char in this.devanagariDigits;
+    }
+
+    readNumber() {
+        let numStr = '';
+        while (this.pos < this.input.length && (this.isDigit(this.currentChar()) || this.isDevanagariDigit(this.currentChar()))) {
+            let char = this.currentChar();
+            if (this.isDevanagariDigit(char)) {
+                numStr += this.devanagariDigits[char];
+            } else {
+                numStr += char;
+            }
+            this.advance();
+        }
+        return parseFloat(numStr);
+    }
+
+    isIdentifierChar(char) {
+        // Matches letters from any language, numbers, marks (like Devanagari matras/halants), or underscore
+        return /[\p{L}\p{N}\p{M}_]/u.test(char) && !this.isPunctuation(char) && !this.isOperatorChar(char) && !this.isWhitespace(char);
+    }
+
+    readIdentifier() {
+        let id = '';
+        while (this.pos < this.input.length && this.isIdentifierChar(this.currentChar())) {
+            id += this.currentChar();
+            this.advance();
+        }
+        return id;
+    }
+}
+
+module.exports = Lexer;

package/Parser.js

@@ -0,0 +1,268 @@
+class Parser {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.pos = 0;
+    }
+
+    parse() {
+        let ast = { type: 'Program', body: [] };
+        while (!this.isAtEnd()) {
+            ast.body.push(this.parseStatement());
+        }
+        return ast;
+    }
+
+    parseStatement() {
+        if (this.match('KEYWORD', 'अस्ति')) return this.parseVariableDeclaration();
+        if (this.match('KEYWORD', 'वद')) return this.parsePrintStatement();
+        if (this.match('KEYWORD', 'यदि')) return this.parseIfStatement();
+        if (this.match('KEYWORD', 'चक्र')) return this.parseLoopStatement();
+
+        return this.parseExpressionStatement();
+    }
+
+    parseVariableDeclaration() {
+        // अस्ति नाम = "आचार्य";
+        let idToken = this.consume('IDENTIFIER', "Expected variable name after 'अस्ति'.");
+        this.consume('OPERATOR', "Expected '=' after variable name.", '=');
+        let init = this.parseExpression();
+        this.consume('PUNCTUATION', "Expected ';' after variable declaration.", ';');
+        return {
+            type: 'VariableDeclaration',
+            id: idToken.value,
+            init: init
+        };
+    }
+
+    parsePrintStatement() {
+        // वद("सत्यम्");
+        this.consume('PUNCTUATION', "Expected '(' after 'वद'.", '(');
+        let expression = this.parseExpression();
+        this.consume('PUNCTUATION', "Expected ')' after print expression.", ')');
+        this.consume('PUNCTUATION', "Expected ';' after print statement.", ';');
+        return {
+            type: 'PrintStatement',
+            expression: expression
+        };
+    }
+
+    parseIfStatement() {
+        // यदि (क > १०) तर्हि वद("सत्यम्");
+        this.consume('PUNCTUATION', "Expected '(' after 'यदि'.", '(');
+        let condition = this.parseExpression();
+        this.consume('PUNCTUATION', "Expected ')' after condition.", ')');
+
+        this.consume('KEYWORD', "Expected 'तर्हि' after condition in if statement.", 'तर्हि');
+
+        // Single statement or block
+        let consequence;
+        if (this.check('PUNCTUATION', '{')) {
+            consequence = this.parseBlock();
+        } else {
+            consequence = this.parseStatement();
+        }
+
+        return {
+            type: 'IfStatement',
+            condition: condition,
+            consequence: consequence
+        };
+    }
+
+    parseLoopStatement() {
+        // चक्र (i = १; i < ५) { ... }
+        this.consume('PUNCTUATION', "Expected '(' after 'चक्र'.", '(');
+
+        let init = null;
+        if (!this.check('PUNCTUATION', ';')) {
+            if (this.check('IDENTIFIER')) {
+                let idToken = this.consume('IDENTIFIER');
+                this.consume('OPERATOR', "Expected '=' in loop initialization.", '=');
+                let value = this.parseExpression();
+                init = { type: 'Assignment', left: idToken.value, right: value };
+            } else {
+                throw new Error("Invalid initialization in loop.");
+            }
+        }
+        this.consume('PUNCTUATION', "Expected ';' after loop initialization.", ';');
+
+        let test = null;
+        if (!this.check('PUNCTUATION', ';')) {
+            test = this.parseExpression();
+        }
+        this.consume('PUNCTUATION', "Expected ';' after loop condition.", ';');
+
+        // Handling post-increment (e.g. i = i + 1 as currently parsing assignment might need special parsing)
+        // For simplicity based on specs, let's say the update might be missing or parsed as assignment
+        let update = null;
+        if (!this.check('PUNCTUATION', ')')) {
+             if (this.check('IDENTIFIER')) {
+                let idToken = this.consume('IDENTIFIER');
+                this.consume('OPERATOR', "Expected '=' in loop update.", '=');
+                let value = this.parseExpression();
+                update = { type: 'Assignment', left: idToken.value, right: value };
+            }
+        }
+        this.consume('PUNCTUATION', "Expected ')' after loop update.", ')');
+
+        let body;
+        if (this.check('PUNCTUATION', '{')) {
+            body = this.parseBlock();
+        } else {
+            body = { type: 'BlockStatement', body: [this.parseStatement()] };
+        }
+
+        return {
+            type: 'LoopStatement',
+            init: init,
+            test: test,
+            update: update,
+            body: body
+        };
+    }
+
+    parseExpressionStatement() {
+        // e.g. a = 5;
+        if (this.check('IDENTIFIER')) {
+            let nextToken = this.tokens[this.pos + 1];
+            if (nextToken && nextToken.type === 'OPERATOR' && nextToken.value === '=') {
+                let idToken = this.consume('IDENTIFIER');
+                this.consume('OPERATOR', "Expected '='", '=');
+                let right = this.parseExpression();
+                this.consume('PUNCTUATION', "Expected ';'", ';');
+                return {
+                    type: 'ExpressionStatement',
+                    expression: {
+                        type: 'Assignment',
+                        left: idToken.value,
+                        right: right
+                    }
+                };
+            }
+        }
+
+        let expr = this.parseExpression();
+        this.consume('PUNCTUATION', "Expected ';' after expression.", ';');
+        return {
+            type: 'ExpressionStatement',
+            expression: expr
+        };
+    }
+
+    parseBlock() {
+        this.consume('PUNCTUATION', "Expected '{'.", '{');
+        let statements = [];
+        while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
+            statements.push(this.parseStatement());
+        }
+        this.consume('PUNCTUATION', "Expected '}'.", '}');
+        return {
+            type: 'BlockStatement',
+            body: statements
+        };
+    }
+
+    parseExpression() {
+        return this.parseEquality();
+    }
+
+    parseEquality() {
+        let expr = this.parseRelational();
+        while (this.match('OPERATOR', '==') || this.match('OPERATOR', '!=')) {
+            let operator = this.previous().value;
+            let right = this.parseRelational();
+            expr = { type: 'BinaryExpression', operator, left: expr, right };
+        }
+        return expr;
+    }
+
+    parseRelational() {
+        let expr = this.parseAdditive();
+        while (this.match('OPERATOR', '<') || this.match('OPERATOR', '<=') ||
+               this.match('OPERATOR', '>') || this.match('OPERATOR', '>=')) {
+            let operator = this.previous().value;
+            let right = this.parseAdditive();
+            expr = { type: 'BinaryExpression', operator, left: expr, right };
+        }
+        return expr;
+    }
+
+    parseAdditive() {
+        let expr = this.parseMultiplicative();
+        while (this.match('OPERATOR', '+') || this.match('OPERATOR', '-')) {
+            let operator = this.previous().value;
+            let right = this.parseMultiplicative();
+            expr = { type: 'BinaryExpression', operator, left: expr, right };
+        }
+        return expr;
+    }
+
+    parseMultiplicative() {
+        let expr = this.parsePrimary();
+        while (this.match('OPERATOR', '*') || this.match('OPERATOR', '/')) {
+            let operator = this.previous().value;
+            let right = this.parsePrimary();
+            expr = { type: 'BinaryExpression', operator, left: expr, right };
+        }
+        return expr;
+    }
+
+    parsePrimary() {
+        if (this.match('NUMBER')) {
+            return { type: 'Literal', value: this.previous().value };
+        }
+        if (this.match('STRING')) {
+            return { type: 'Literal', value: this.previous().value };
+        }
+        if (this.match('IDENTIFIER')) {
+            return { type: 'Identifier', name: this.previous().value };
+        }
+        if (this.match('PUNCTUATION', '(')) {
+            let expr = this.parseExpression();
+            this.consume('PUNCTUATION', "Expected ')' after expression.", ')');
+            return expr;
+        }
+
+        throw new Error(`Parser Error: Unexpected token '${this.peek().value}' at line ${this.peek().line}, col ${this.peek().col}`);
+    }
+
+    match(type, value = null) {
+        if (this.check(type, value)) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+
+    check(type, value = null) {
+        if (this.isAtEnd()) return false;
+        let token = this.peek();
+        if (token.type !== type) return false;
+        if (value !== null && token.value !== value) return false;
+        return true;
+    }
+
+    advance() {
+        if (!this.isAtEnd()) this.pos++;
+        return this.previous();
+    }
+
+    isAtEnd() {
+        return this.peek().type === 'EOF';
+    }
+
+    peek() {
+        return this.tokens[this.pos];
+    }
+
+    previous() {
+        return this.tokens[this.pos - 1];
+    }
+
+    consume(type, message, value = null) {
+        if (this.check(type, value)) return this.advance();
+        throw new Error(`Parser Error: ${message} Found '${this.peek().value}' at line ${this.peek().line}, col ${this.peek().col}`);
+    }
+}
+
+module.exports = Parser;

package/README.md

@@ -0,0 +1,77 @@
+# Nava Sanskritam (नव संस्कृतम्)
+
+A professional, high-performance programming language built on Panini's Ashtadhyayi logic, created by **NavaSanganakah Multiventures**.
+
+## Vedic Vision
+
+At NavaSanganakah Multiventures, we blend the ancient intelligence of Vedic sciences with modern computation. Panini's grammatical rules in Ashtadhyayi lay out a complete, unambiguous algorithmic framework that predates modern computer science by millennia. Nava Sanskritam is our proprietary, production-ready execution engine designed to bring this profound logic directly into modern software development, providing developers with a robust, modular, and performant AST-based interpreter.
+
+## Installation
+
+You can install the Nava CLI globally on your local machine using `npm link` to map the `nava` command to your environment:
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd nava
+
+# Install dependencies
+npm install
+
+# Link the package globally
+npm link
+```
+
+After installation, you can use the command globally:
+
+```bash
+nava run yourfile.ns
+```
+
+## Syntax Specs
+
+Nava Sanskritam supports a robust core of programmatic concepts using Devanagari numerals and Sanskrit keywords.
+
+### Variable Declaration (अस्ति)
+Use `अस्ति` to declare variables.
+
+```sanskrit
+अस्ति नाम = "आचार्य";
+अस्ति क = १०;
+```
+
+### Output (वद)
+Use `वद` to print expressions to the console.
+
+```sanskrit
+वद("सत्यम्");
+वद(नाम);
+```
+
+### Conditionals (यदि-तर्हि)
+Use `यदि` for conditions and `तर्हि` for execution blocks if the condition is met.
+
+```sanskrit
+यदि (क > ५) तर्हि वद("सत्यम्");
+
+यदि (क > ५) तर्हि {
+    वद("सत्यम्");
+}
+```
+
+### Loops (चक्र)
+Use `चक्र` to create iterative loops using standard or Devanagari numerals.
+
+```sanskrit
+चक्र (i = १; i < ५; i = i + १) {
+    वद(i);
+}
+```
+
+## Development and Architecture
+- `Lexer.js`: Robust tokenizer supporting UTF-8 identifiers, Paninian keywords, and Devanagari Numerals.
+- `Parser.js`: Builds an Abstract Syntax Tree (AST) utilizing standard logical bindings and structures.
+- `Interpreter.js`: AST execution engine complete with lexical environment scoping.
+
+## License
+Proprietary software of NavaSanganakah Multiventures. All Rights Reserved.

package/bin/nava.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const fs = require('fs');
+const path = require('path');
+
+const Lexer = require('../Lexer');
+const Parser = require('../Parser');
+const Interpreter = require('../Interpreter');
+
+program
+    .name('nava')
+    .description('Nava Sanskritam (Panini\'s Ashtadhyayi logic engine CLI)')
+    .version('1.0.0');
+
+program
+    .command('run <file>')
+    .description('Execute a Nava Sanskritam (.ns) script')
+    .action((file) => {
+        try {
+            if (!file.endsWith('.ns')) {
+                console.error("दोषः (Error): कृपया '.ns' इति विस्तारयुक्तं सञ्चिकां प्रयच्छतु। (Please provide a file with a '.ns' extension.)");
+                process.exit(1);
+            }
+
+            const filePath = path.resolve(process.cwd(), file);
+
+            if (!fs.existsSync(filePath)) {
+                console.error(`दोषः (Error): सञ्चिका न प्राप्ता। (File not found: ${file})`);
+                process.exit(1);
+            }
+
+            const input = fs.readFileSync(filePath, 'utf-8');
+
+            const lexer = new Lexer(input);
+            const tokens = lexer.tokenize();
+
+            const parser = new Parser(tokens);
+            const ast = parser.parse();
+
+            const interpreter = new Interpreter();
+            interpreter.interpret(ast);
+
+        } catch (error) {
+            console.error(`दोषः (Error during execution):\n${error.message}`);
+            process.exit(1);
+        }
+    });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "nava-sanskritam",
+  "version": "1.0.0",
+  "description": "Nava Sanskritam - A revolutionary programming language based on Panini's Ashtadhyayi logic.",
+  "main": "Interpreter.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node bin/nava.js"
+  },
+  "keywords": [
+    "Sanskrit",
+    "Vedic",
+    "Programming",
+    "Ashtadhyayi",
+    "NavaSanganakah",
+    "Panini"
+  ],
+  "author": "Acharya Pandit Dheerendra Tripathi (NavaSanganakah Multiventures)",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^14.0.3"
+  },
+  "bin": {
+    "nava": "bin/nava.js"
+  },
+  "private": false
+}

package/sankalpa.ns

@@ -0,0 +1,13 @@
+अस्ति आचार्यः = "धीरेन्द्र त्रिपाठी";
+अस्ति मिशनम् = "नवा संस्कृतम्";
+अस्ति सफलता_अंक = १०८;
+
+वद(आचार्यः);
+वद(मिशनम्);
+
+यदि (सफलता_अंक > १००) 
+    तर्हि वद("अष्टाध्यायी लॉजिक सक्रिय अस्ति!");
+
+चक्र (i = १; i < ४; i = i + १) {
+    वद("जयतु संस्कृतम्");
+}