rei-lang 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nobuki Fujimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# Rei (0₀式) — D-FUMT Computational Language
+
+[![npm version](https://img.shields.io/npm/v/rei-lang)](https://www.npmjs.com/package/rei-lang)
+[![License: MIT](https://img.shields.io/badge/License-MIT-gold.svg)](./LICENSE)
+[![Tests](https://img.shields.io/badge/tests-85%2F85-brightgreen)]()
+
+**Rei** (0₀式 / れいしき) is a mathematical computation language based on **D-FUMT** (Dimensional Fujimoto Universal Mathematical Theory). Its center-periphery patterns as language primitives achieve an **average 74% code reduction** over equivalent implementations in general-purpose languages.
+
+**Author:** Nobuki Fujimoto
+
+---
+
+## Install
+
+```bash
+npm install rei-lang
+```
+
+## Quick Start
+
+### As a Library
+
+```typescript
+import { rei } from 'rei-lang';
+
+// Multi-dimensional number computation
+rei('let field = 𝕄{5; 1, 2, 3, 4}');
+const result = rei('field |> compute :weighted');
+console.log(result); // 7.5
+
+// Define functions with compress
+rei('compress energy(m) = m |> compute :weighted');
+rei('let e = energy(𝕄{0; 10, 20, 30})');
+console.log(rei('e')); // 20
+
+// Genesis axiom system
+rei('let g = genesis()');
+rei('g |> forward');
+rei('g |> forward');
+console.log(rei('g.state')); // "line"
+
+// Reset state between sessions
+rei.reset();
+```
+
+### Interactive REPL
+
+```bash
+npx rei
+```
+
+```
+ ╔══════════════════════════════════════════╗
+ ║  Rei (0₀式) REPL v0.2.0                  ║
+ ║  D-FUMT Computational Language           ║
+ ╚══════════════════════════════════════════╝
+
+零 > 𝕄{5; 1, 2, 3, 4} |> compute :weighted
+7.5
+
+零 > compress karma(i, e, r) = i * e * r
+compress karma(i, e, r)
+
+零 > karma(0.8, 0.9, 0.7)
+0.504
+```
+
+### Execute a File
+
+```bash
+npx rei program.rei
+```
+
+### Inline Evaluation
+
+```bash
+npx rei -e "2 + 3 * 4"
+# → 14
+```
+
+---
+
+## Language Features
+
+### Multi-Dimensional Numbers (𝕄)
+
+The core data structure. A center value with peripheral neighbors, computed in 4 modes:
+
+```rei
+let m = 𝕄{5; 1, 2, 3, 4}
+
+m |> compute :weighted       // center + weighted avg of neighbors
+m |> compute :multiplicative  // center × Π(1 + nᵢ)
+m |> compute :harmonic        // center + n / Σ(1/|nᵢ|)
+m |> compute :exponential     // center × avg(e^nᵢ)
+```
+
+### Extended Numbers (拡張数)
+
+Numbers with subscript-based dimensional extension:
+
+```rei
+let a = 0ooo       // 3rd-order extension of zero
+a >> :x >> :x      // extend: order 3 → 5
+a <<               // reduce: order 3 → 2
+a |> valStar       // numeric projection: 0.001
+
+πooo               // π extended to 3rd order
+0₀                 // D-FUMT zero symbol
+```
+
+### Compress (関数定義)
+
+Functions are defined with `compress` — reflecting D-FUMT's compression philosophy:
+
+```rei
+compress distance(x, y) = sqrt(x * x + y * y)
+compress field(c, r) = 𝕄{c; r, r, r, r}
+
+distance(3, 4)           // 5
+field(10, 2) |> compute :weighted  // 12
+```
+
+### Pipe Operator (|>)
+
+Center-to-periphery data flow:
+
+```rei
+-25 |> abs |> sqrt              // 5
+[3, 1, 2] |> sort |> reverse    // [3, 2, 1]
+"hello" |> upper                // "HELLO"
+𝕄{0; 1, 2, 3} |> normalize     // normalized neighbors
+```
+
+### Genesis Axiom System (生成公理系)
+
+Models computational emergence from void:
+
+```rei
+let g = genesis()   // void
+g |> forward        // void → dot
+g |> forward        // dot → line
+g |> forward        // line → surface
+g |> forward        // surface → solid
+g |> forward        // solid → omega (Ω)
+g.omega             // 1
+```
+
+Or from the primordial dot (・):
+
+```rei
+let g = ・
+g |> forward        // dot
+g |> forward        // line
+```
+
+### Four-Valued Logic (四価0π)
+
+Beyond true/false — Theory #21:
+
+```rei
+⊤           // true
+⊥           // false
+⊤π          // true-pi (π-rotated truth)
+⊥π          // false-pi
+
+¬⊤          // ⊥
+⊤ ∧ ⊥      // ⊥
+⊥ ∨ ⊤      // ⊤
+```
+
+### Variable Binding
+
+```rei
+let x = 42           // immutable
+let mut y = 10       // mutable
+```
+
+---
+
+## Benchmarks
+
+| Task | Conventional | Rei | Reduction |
+|------|-------------|-----|-----------|
+| Image kernel calculations | 32 lines | 8 lines | **4×** |
+| Multi-dimensional data aggregation | 45 lines | 12 lines | **3.7×** |
+| Graph structure transformation | 52 lines | 14 lines | **3.7×** |
+| **Average** | | | **74%** |
+
+---
+
+## API Reference
+
+### `rei(code: string): ReiValue`
+
+Evaluate a string of Rei code. State persists across calls.
+
+### `rei.reset(): void`
+
+Clear all variable and function bindings.
+
+### `rei.parse(code: string): ASTNode`
+
+Parse code and return the AST without evaluating.
+
+### `rei.tokenize(code: string): Token[]`
+
+Tokenize code and return the token stream.
+
+### Classes
+
+- `Lexer` — Tokenizer
+- `Parser` — Recursive descent parser
+- `Evaluator` — AST evaluator with environment/scope chain
+- `Environment` — Scope management
+
+### Types
+
+- `MultiDimNumber` — `{ center, neighbors, mode, weights? }`
+- `ReiExtended` — `{ base, order, subscripts, valStar() }`
+- `GenesisState` — `{ state, omega, history }`
+- `ReiFunction` — `{ name, params, body, closure }`
+- `Quad` — `{ value: 'top' | 'bottom' | 'topPi' | 'bottomPi' }`
+
+---
+
+## BNF Specification
+
+The complete BNF v0.2 specification is in [`spec/REI_BNF_v0.2.md`](./spec/REI_BNF_v0.2.md).
+
+Key features integrated from 21 D-FUMT theories:
+- 45 keywords, 10 operators, 9 types
+- Full backward compatibility with v0.1
+- Complete operator precedence table
+
+---
+
+## Theoretical Foundation
+
+Rei is grounded in **D-FUMT** (Dimensional Fujimoto Universal Mathematical Theory), a framework of 66 interconnected theories spanning pure mathematics to philosophy and AI consciousness. The language's core innovation — **center-periphery patterns as language primitives** — derives from D-FUMT's multi-dimensional number system theory.
+
+---
+
+## License
+
+MIT © Nobuki Fujimoto

package/bin/rei.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+// ============================================================
+// Rei (0₀式) CLI — REPL & File Execution
+// Author: Nobuki Fujimoto
+// ============================================================
+
+const { Lexer } = require('../dist/index.js');
+const { Parser } = require('../dist/index.js');
+const { Evaluator } = require('../dist/index.js');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const VERSION = '0.2.0';
+
+// --- Result formatting ---
+function formatResult(val) {
+  if (val === null || val === undefined) return 'null';
+  if (typeof val === 'number') return String(val);
+  if (typeof val === 'string') return `"${val}"`;
+  if (typeof val === 'boolean') return String(val);
+  if (Array.isArray(val)) return `[${val.map(formatResult).join(', ')}]`;
+
+  if (val && typeof val === 'object') {
+    switch (val.reiType) {
+      case 'Ext':
+        return `Ext(base=${val.base}, order=${val.order}, subs="${val.subscripts}", val*=${val.valStar()})`;
+      case 'MDim':
+        return `𝕄{${val.center}; ${val.neighbors.join(', ')}} :${val.mode}`;
+      case 'State':
+        return `Genesis(${val.state}, ω=${val.omega})`;
+      case 'Function':
+        return `compress ${val.name}(${val.params.join(', ')})`;
+      case 'Quad':
+        const sym = { top: '⊤', bottom: '⊥', topPi: '⊤π', bottomPi: '⊥π' };
+        return sym[val.value] || val.value;
+      default:
+        return JSON.stringify(val);
+    }
+  }
+  return String(val);
+}
+
+// --- Evaluate code string ---
+function evaluate(code, evaluator) {
+  const lexer = new Lexer(code);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parseProgram();
+  return evaluator.eval(ast);
+}
+
+// --- CLI argument parsing ---
+const args = process.argv.slice(2);
+
+if (args.includes('--version') || args.includes('-v')) {
+  console.log(`rei-lang v${VERSION}`);
+  process.exit(0);
+}
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+Rei (0₀式) — D-FUMT Computational Language v${VERSION}
+
+Usage:
+  rei                    Start interactive REPL
+  rei <file.rei>         Execute a Rei source file
+  rei -e "<code>"        Evaluate inline code
+  rei --version          Show version
+  rei --help             Show this help
+
+REPL commands:
+  :env                   Show all bindings
+  :ast <code>            Show AST for code
+  :tokens <code>         Show token stream
+  :reset                 Clear all state
+  :quit                  Exit REPL
+
+Author: Nobuki Fujimoto
+`);
+  process.exit(0);
+}
+
+// --- Inline eval: -e ---
+const eIdx = args.indexOf('-e');
+if (eIdx >= 0 && args[eIdx + 1]) {
+  try {
+    const evaluator = new Evaluator();
+    const result = evaluate(args[eIdx + 1], evaluator);
+    console.log(formatResult(result));
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// --- File execution ---
+if (args.length > 0 && !args[0].startsWith('-')) {
+  const filePath = path.resolve(args[0]);
+  try {
+    const code = fs.readFileSync(filePath, 'utf-8');
+    const evaluator = new Evaluator();
+    const result = evaluate(code, evaluator);
+    if (result !== null && result !== undefined) {
+      console.log(formatResult(result));
+    }
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      console.error(`File not found: ${filePath}`);
+    } else {
+      console.error(`Error: ${e.message}`);
+    }
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// --- Interactive REPL ---
+console.log(`
+ ╔══════════════════════════════════════════╗
+ ║  Rei (0₀式) REPL v${VERSION}                  ║
+ ║  D-FUMT Computational Language           ║
+ ║  Author: Nobuki Fujimoto                 ║
+ ╚══════════════════════════════════════════╝
+
+ Type :help for commands, :quit to exit
+`);
+
+const evaluator = new Evaluator();
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: '\x1b[33m零 >\x1b[0m ',
+});
+
+rl.prompt();
+
+rl.on('line', (input) => {
+  const trimmed = input.trim();
+  if (!trimmed) { rl.prompt(); return; }
+
+  // Meta commands
+  if (trimmed === ':quit' || trimmed === ':q') {
+    console.log('\nさようなら');
+    process.exit(0);
+  }
+  if (trimmed === ':help' || trimmed === ':h') {
+    console.log('  :env      Show all bindings');
+    console.log('  :ast      Show AST for last input');
+    console.log('  :tokens   Show token stream');
+    console.log('  :reset    Clear state');
+    console.log('  :quit     Exit');
+    rl.prompt();
+    return;
+  }
+  if (trimmed === ':reset') {
+    Object.assign(evaluator, new Evaluator());
+    console.log('  State reset.');
+    rl.prompt();
+    return;
+  }
+  if (trimmed === ':env') {
+    const bindings = evaluator.env.allBindings();
+    for (const [k, v] of bindings) {
+      if (v.value && typeof v.value === 'object' && v.value.reiType === 'Function' && !v.value.body) continue;
+      console.log(`  ${v.mutable ? 'mut ' : ''}${k} = ${formatResult(v.value)}`);
+    }
+    rl.prompt();
+    return;
+  }
+  if (trimmed.startsWith(':ast ')) {
+    try {
+      const code = trimmed.slice(5);
+      const lexer = new Lexer(code);
+      const tokens = lexer.tokenize();
+      const parser = new Parser(tokens);
+      const ast = parser.parseProgram();
+      console.log(JSON.stringify(ast, null, 2));
+    } catch (e) { console.log(`\x1b[31m${e.message}\x1b[0m`); }
+    rl.prompt();
+    return;
+  }
+  if (trimmed.startsWith(':tokens ')) {
+    try {
+      const code = trimmed.slice(8);
+      const lexer = new Lexer(code);
+      const tokens = lexer.tokenize();
+      tokens.forEach(t => console.log(`  ${t.type.padEnd(15)} ${JSON.stringify(t.value)}`));
+    } catch (e) { console.log(`\x1b[31m${e.message}\x1b[0m`); }
+    rl.prompt();
+    return;
+  }
+
+  // Evaluate
+  try {
+    const result = evaluate(trimmed, evaluator);
+    const out = formatResult(result);
+    if (out !== 'null' && out !== 'undefined') {
+      console.log(`\x1b[33m${out}\x1b[0m`);
+    }
+  } catch (e) {
+    console.log(`\x1b[31m${e.message}\x1b[0m`);
+  }
+  rl.prompt();
+});
+
+rl.on('close', () => {
+  console.log('\nさようなら');
+  process.exit(0);
+});