rei-lang 0.3.0 → 0.4.0

package/bin/rei.js

@@ -1,144 +1,259 @@
-#!/usr/bin/env node
-
-// ============================================================
-// Rei v0.3 CLI — D-FUMT Computational Language
-// Space-Layer-Diffusion + Category C (25 Axioms)
-// Author: Nobuki Fujimoto
-// ============================================================
-
-const VERSION = '0.3.0';
-
-async function main() {
-  // Dynamic import for ESM compatibility
-  const { Lexer, Parser, Evaluator } = await import('../dist/index.js');
-
-  const args = process.argv.slice(2);
-
-  // --version / -v
-  if (args.includes('--version') || args.includes('-v')) {
-    console.log(`Rei (0₀式) v${VERSION}`);
-    process.exit(0);
-  }
-
-  // --help / -h
-  if (args.includes('--help') || args.includes('-h')) {
-    console.log(`
-  Rei (0₀式/れいしき) v${VERSION}
-  D-FUMT Computational Language — Space-Layer-Diffusion + Category C (25 Axioms)
-
-  Usage:
-    rei                    Start interactive REPL
-    rei <file.rei>         Execute a Rei source file
-    rei -e "<code>"        Evaluate code directly
-    rei --version          Show version
-    rei --help             Show this help
-
-  Examples:
-    rei -e "𝕄{5; 1, 2, 3} |> compute"
-    rei -e "42 |> sigma"
-    rei -e "[1, 5, 3] |> project('max') |> consensus"
-    rei -e "𝕄{5; 1, 2, 3} |> encode |> decode('array')"
-
-  v0.3 New Features:
-    Category C — 25 consciousness axioms (C1-C5, N1-N5, M1-M5, U1-U5, A1-A5)
-    Space-Layer-Diffusion — spatial computation model
-    226 tests passing
-
-  Homepage: https://github.com/fc0web/rei-lang
-  npm:      https://www.npmjs.com/package/rei-lang
-`);
-    process.exit(0);
-  }
-
-  // -e "<code>" — evaluate code
-  const eIdx = args.indexOf('-e');
-  if (eIdx >= 0 && args[eIdx + 1]) {
-    const ev = new Evaluator();
-    try {
-      const tokens = new Lexer(args[eIdx + 1]).tokenize();
-      const ast = new Parser(tokens).parseProgram();
-      const result = ev.eval(ast);
-      if (result !== undefined && result !== null) {
-        console.log(typeof result === 'object' ? JSON.stringify(result, null, 2) : result);
-      }
-    } catch (e) {
-      console.error('Error:', e.message);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-
-  // <file.rei> — execute file
-  if (args.length > 0 && !args[0].startsWith('-')) {
-    const fs = await import('fs');
-    const path = await import('path');
-    const filePath = path.resolve(args[0]);
-    try {
-      const code = fs.readFileSync(filePath, 'utf-8');
-      const ev = new Evaluator();
-      const tokens = new Lexer(code).tokenize();
-      const ast = new Parser(tokens).parseProgram();
-      const result = ev.eval(ast);
-      if (result !== undefined && result !== null) {
-        console.log(typeof result === 'object' ? JSON.stringify(result, null, 2) : result);
-      }
-    } catch (e) {
-      console.error('Error:', e.message);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-
-  // REPL mode
-  const readline = await import('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: 'rei> ',
-  });
-
-  console.log(`Rei (0₀式) v${VERSION} — D-FUMT Computational Language`);
-  console.log('Category C: 25 axioms | 226 tests | Space-Layer-Diffusion');
-  console.log('Type "exit" or Ctrl+C to quit.\n');
-
-  const ev = new Evaluator();
-  rl.prompt();
-
-  rl.on('line', (line) => {
-    const input = line.trim();
-    if (input === 'exit' || input === 'quit') {
-      rl.close();
-      process.exit(0);
-    }
-    if (!input) {
-      rl.prompt();
-      return;
-    }
-
-    try {
-      const tokens = new Lexer(input).tokenize();
-      const ast = new Parser(tokens).parseProgram();
-      const result = ev.eval(ast);
-      if (result !== undefined && result !== null) {
-        if (typeof result === 'object') {
-          console.log(JSON.stringify(result, null, 2));
-        } else {
-          console.log(result);
-        }
-      }
-    } catch (e) {
-      console.error('Error:', e.message);
-    }
-    rl.prompt();
-  });
-
-  rl.on('close', () => {
-    console.log('\nさようなら。');
-    process.exit(0);
-  });
-}
-
-main().catch((e) => {
-  console.error('Fatal:', e.message);
-  process.exit(1);
-});
+#!/usr/bin/env node
+
+// ============================================================
+// Rei (0₀式) CLI — REPL & File Execution
+// v0.3 — Space-Layer-Diffusion Model
+// 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.3.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;
+      // ── v0.3 Space-Layer-Diffusion ──
+      case 'Space': {
+        const layers = [];
+        for (const [idx, layer] of val.layers) {
+          const nodes = layer.nodes.map(n =>
+            `𝕄{${n.center}; ${n.neighbors.slice(0, 4).join(', ')}${n.neighbors.length > 4 ? ', ...' : ''}}[stage=${n.stage}]`
+          ).join(', ');
+          const frozen = layer.frozen ? ' ❄' : '';
+          layers.push(`  層 ${idx}${frozen}: ${nodes}`);
+        }
+        return `空{${val.topology !== 'flat' ? ` topology: ${val.topology}` : ''}\n${layers.join('\n')}\n} [global_stage=${val.globalStage}]`;
+      }
+      case 'DNode': {
+        const ns = val.neighbors.slice(0, 4).join(', ') + (val.neighbors.length > 4 ? `, ... (${val.neighbors.length}方向)` : '');
+        return `DNode{${val.center}; ${ns}} [stage=${val.stage}, ${val.momentum}]`;
+      }
+      case 'SigmaResult': {
+        return `σ{ flow: {stage=${val.flow.stage}, dirs=${val.flow.directions}, ${val.flow.momentum}}, layer=${val.layer}, memory=[${val.memory.length}] }`;
+      }
+      default:
+        // Handle plain objects (sigma sub-objects, resonance pairs, etc.)
+        if (val.similarity !== undefined && val.nodeA && val.nodeB) {
+          return `Resonance(層${val.nodeA.layer}[${val.nodeA.index}] ↔ 層${val.nodeB.layer}[${val.nodeB.index}], sim=${val.similarity})`;
+        }
+        if (val.stage !== undefined && val.momentum !== undefined && val.directions !== undefined) {
+          return `σ.flow{stage=${val.stage}, dirs=${val.directions}, ${val.momentum}, v=${val.velocity}}`;
+        }
+        if (val.tendency !== undefined && val.strength !== undefined) {
+          return `σ.will{τ=${val.tendency}, strength=${val.strength}}`;
+        }
+        if (val.layers !== undefined && val.total_nodes !== undefined) {
+          return `σ.field{layers=${val.layers}, nodes=${val.total_nodes}, active=${val.active_nodes}}`;
+        }
+        if (val.global_stage !== undefined) {
+          return `σ.flow{global_stage=${val.global_stage}, converged=${val.converged_nodes}, expanding=${val.expanding_nodes}}`;
+        }
+        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}
+Space-Layer-Diffusion Model (場-層-拡散計算モデル)
+
+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
+
+v0.3 New Features:
+  空{ 層 N: 𝕄{...} }    Space literal with layers
+  s |> step              Single diffusion step
+  s |> diffuse(N)        Diffuse N steps
+  s |> sigma             Self-reference (σ)
+  s |> freeze(N)         Freeze layer N
+  s |> thaw(N)           Thaw layer N
+  s |> resonances(0.5)   Find resonance pairs
+
+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               ║
+ ║  Space-Layer-Diffusion Model (場-層-拡散)    ║
+ ║  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);
+});

package/dist/index.d.mts

@@ -0,0 +1,257 @@
+/** 結合モード */
+type BindingMode = 'mirror' | 'inverse' | 'resonance' | 'entangle' | 'causal';
+/** 伝播規則 */
+interface PropagationRule {
+    type: 'immediate' | 'delayed' | 'attenuated';
+    delay: number;
+    attenuation: number;
+}
+/** 結合イベント — 記憶属性との統合 */
+interface BindingEvent {
+    step: number;
+    type: 'created' | 'propagated' | 'broken' | 'strengthened' | 'weakened';
+    sourceValue: any;
+    targetValue: any;
+    delta: number;
+}
+/** 結合（Binding）— 2つの値の非局所的な関係 */
+interface ReiBinding {
+    id: string;
+    sourceRef: string;
+    targetRef: string;
+    mode: BindingMode;
+    strength: number;
+    propagation: PropagationRule;
+    bidirectional: boolean;
+    active: boolean;
+    history: BindingEvent[];
+    createdAt: number;
+}
+/** 結合の要約（σ.relation に含める用） */
+interface BindingSummary {
+    id: string;
+    target: string;
+    mode: BindingMode;
+    strength: number;
+    active: boolean;
+    propagationCount: number;
+}
+/**
+ * 結合レジストリ — 全結合を管理し、伝播を実行する
+ *
+ * Evaluator内に1つのインスタンスを保持する。
+ * 変数への代入（Environment.set）時に propagate() が呼ばれ、
+ * 結合先に変更が自動的に伝播する。
+ */
+declare class BindingRegistry {
+    private bindings;
+    private refIndex;
+    private globalStep;
+    private _propagating;
+    /**
+     * 2つの変数参照を結合する
+     *
+     * @param sourceRef 結合元の変数名
+     * @param targetRef 結合先の変数名
+     * @param mode      結合モード
+     * @param strength  結合の強さ (0.0~1.0)
+     * @param bidirectional 双方向結合にするか
+     * @param propagation   伝播規則
+     * @returns 作成された結合
+     */
+    bind(sourceRef: string, targetRef: string, mode?: BindingMode, strength?: number, bidirectional?: boolean, propagation?: PropagationRule): ReiBinding;
+    /**
+     * 変数の値が変化したとき、結合先に変更を伝播する
+     *
+     * @param changedRef 変更された変数名
+     * @param newValue   新しい値
+     * @param getValue   変数の値を取得する関数
+     * @param setValue   変数の値を設定する関数
+     * @returns 伝播された結合の数
+     */
+    propagate(changedRef: string, newValue: any, getValue: (ref: string) => any, setValue: (ref: string, value: any) => void): number;
+    private computePropagatedValue;
+    /**
+     * 2つの変数間の結合を解除する
+     */
+    unbind(sourceRef: string, targetRef: string): boolean;
+    /**
+     * 変数に関連する全結合を解除する
+     */
+    unbindAll(ref: string): number;
+    /**
+     * 変数に関連する全結合の要約を返す
+     */
+    getBindingsFor(ref: string): BindingSummary[];
+    /**
+     * 全結合を返す
+     */
+    getAllBindings(): ReiBinding[];
+    /**
+     * アクティブな結合の数を返す
+     */
+    get activeCount(): number;
+    /**
+     * レジストリをリセットする
+     */
+    reset(): void;
+    /**
+     * 変数のσ.relation情報を構築する
+     */
+    buildRelationSigma(ref: string): any[];
+    private findBinding;
+    private addToIndex;
+}
+
+interface SigmaMetadata {
+    memory: any[];
+    tendency: string;
+    pipeCount: number;
+}
+declare class Environment {
+    parent: Environment | null;
+    bindings: Map<string, {
+        value: any;
+        mutable: boolean;
+    }>;
+    constructor(parent?: Environment | null);
+    define(name: string, value: any, mutable?: boolean): void;
+    get(name: string): any;
+    set(name: string, value: any): void;
+    has(name: string): boolean;
+    getBinding(name: string): any;
+    allBindings(): Map<string, {
+        value: any;
+        mutable: boolean;
+    }>;
+}
+declare class Evaluator {
+    env: Environment;
+    bindingRegistry: BindingRegistry;
+    constructor(parent?: Environment);
+    private registerBuiltins;
+    eval(ast: any): any;
+    private evalProgram;
+    private evalConstLit;
+    private evalMDimLit;
+    private evalSpaceLit;
+    private evalLetStmt;
+    private evalMutStmt;
+    private evalCompressDef;
+    private evalBinOp;
+    private evalUnaryOp;
+    private evalPipe;
+    private execPipeCmd;
+    private evalFnCall;
+    private callFunction;
+    private callBuiltin;
+    private evalMemberAccess;
+    private evalIndexAccess;
+    private evalExtend;
+    private evalReduce;
+    private evalConverge;
+    private evalDiverge;
+    private evalReflect;
+    private evalIfExpr;
+    private evalMatchExpr;
+    toNumber(val: any): number;
+    private isTruthy;
+    private matches;
+    isObj(v: any): boolean;
+    isMDim(v: any): boolean;
+    isExt(v: any): boolean;
+    isGenesis(v: any): boolean;
+    isFunction(v: any): boolean;
+    isQuad(v: any): boolean;
+    isSpace(v: any): boolean;
+    isDNode(v: any): boolean;
+    isReiVal(v: any): boolean;
+    isStringMDim(v: any): boolean;
+    /** 値からσメタデータを取得（Tier 1） */
+    getSigmaMetadata(v: any): SigmaMetadata;
+    /** ReiValを透過的にアンラップ */
+    unwrap(v: any): any;
+    /** 値からその変数名を逆引きする（参照一致） */
+    findRefByValue(value: any): string | null;
+    /** 結合の伝播をトリガーする（変数名 + 新値） */
+    triggerPropagation(ref: string, newValue: any): number;
+}
+
+interface Token {
+    type: string;
+    value: string;
+    line: number;
+    col: number;
+}
+declare class Lexer {
+    private source;
+    private chars;
+    private pos;
+    private line;
+    private col;
+    private tokens;
+    constructor(source: string);
+    tokenize(): Token[];
+    private skipWhitespaceAndComments;
+    private readString;
+    private isExtStart;
+    private readExtLit;
+    private readNumber;
+    private readUnicodeToken;
+    private readMultiCharOp;
+    private readSingleCharOp;
+    private readIdentOrKeyword;
+    private advance;
+    private peek;
+    private emit;
+    private isDigit;
+    private isIdentStart;
+    private isIdentPart;
+    private shouldNegateBePrefix;
+}
+
+declare class Parser {
+    private pos;
+    private tokens;
+    constructor(tokens: Token[]);
+    parseProgram(): any;
+    private parseStatement;
+    private parseLetStmt;
+    private parseCompressDef;
+    private parseCompressLevel;
+    private parseParamDecl;
+    private parseExpression;
+    private parsePipe;
+    private parsePipeCommand;
+    private parseLogicOr;
+    private parseLogicAnd;
+    private parseComparison;
+    private parseAddition;
+    private parseMultiplication;
+    private parseExtendReduce;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseMDimLit;
+    private parseSpaceLit;
+    private parseIfExpr;
+    private parseMatchExpr;
+    private peek;
+    private isAtEnd;
+    private check;
+    private checkAhead;
+    private advance;
+    private match;
+    private expect;
+    private error;
+    private shouldNegateBePrefix;
+}
+
+declare function reiFn(source: string): any;
+declare namespace reiFn {
+    var reset: () => void;
+    var evaluator: () => Evaluator;
+}
+declare const rei: typeof reiFn;
+
+export { Evaluator, Lexer, Parser, rei };