@creationix/rex 0.3.1 → 0.6.0

package/rex-repl.ts

@@ -1,6 +1,9 @@
 import * as readline from "node:readline";
 import { createRequire } from "node:module";
-import { grammar, stringify, parseToIR, optimizeIR, compile } from "./rex.ts";
+import { readdirSync, statSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+import { grammar, stringify, parseToIR, optimizeIR, compile, formatParseError } from "./rex.ts";
 import { evaluateRexc } from "./rexc-interpreter.ts";
 
 const req = createRequire(import.meta.url);
@@ -8,23 +11,69 @@ const { version } = req("./package.json");
 
 // ── ANSI helpers ──────────────────────────────────────────────
 
-const C = {
-	reset: "\x1b[0m",
-	bold: "\x1b[1m",
-	dim: "\x1b[2m",
-	red: "\x1b[31m",
-	green: "\x1b[32m",
-	yellow: "\x1b[33m",
-	blue: "\x1b[34m",
-	cyan: "\x1b[36m",
-	gray: "\x1b[90m",
-	boldBlue: "\x1b[1;34m",
-};
+function createColors(enabled: boolean) {
+	if (!enabled) {
+		return {
+			reset: "",
+			bold: "",
+			dim: "",
+			red: "",
+			green: "",
+			yellow: "",
+			blue: "",
+			magenta: "",
+			cyan: "",
+			gray: "",
+			keyword: "",
+		};
+	}
+	return {
+		reset: "\x1b[0m",
+		bold: "\x1b[1m",
+		dim: "\x1b[2m",
+		red: "\x1b[38;5;203m",
+		green: "\x1b[38;5;114m",
+		yellow: "\x1b[38;5;179m",
+		blue: "\x1b[38;5;75m",
+		magenta: "\x1b[38;5;141m",
+		cyan: "\x1b[38;5;81m",
+		gray: "\x1b[38;5;245m",
+		keyword: "\x1b[1;38;5;208m",
+	};
+}
+
+let colorEnabled = process.stdout.isTTY;
+let C = createColors(colorEnabled);
+
+export function setColorEnabled(enabled: boolean) {
+	colorEnabled = enabled;
+	C = createColors(enabled);
+}
+
+type OutputFormat = "rex" | "json";
+
+function formatJson(value: unknown, indent = 2): string {
+	const normalized = normalizeJsonValue(value, false);
+	const text = JSON.stringify(normalized, null, indent);
+	return text ?? "null";
+}
+
+function normalizeJsonValue(value: unknown, inArray: boolean): unknown {
+	if (value === undefined) return inArray ? null : undefined;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((item) => normalizeJsonValue(item, true));
+	const out: Record<string, unknown> = {};
+	for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+		const normalized = normalizeJsonValue(val, false);
+		if (normalized !== undefined) out[key] = normalized;
+	}
+	return out;
+}
 
 // ── Syntax highlighting ───────────────────────────────────────
 
 const TOKEN_RE =
-	/(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined|nan)(?![a-zA-Z0-9_-])|-?\binf\b)|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)/g;
+	/(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<objKey>\b[A-Za-z_][A-Za-z0-9_-]*\b)(?=\s*:)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|nor|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined|nan)(?![a-zA-Z0-9_-])|-?\binf\b)|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)|(?<identifier>\b[A-Za-z_][A-Za-z0-9_.-]*\b)/g;
 
 export function highlightLine(line: string): string {
 	let result = "";
@@ -39,14 +88,18 @@ export function highlightLine(line: string): string {
 			result += C.gray + text + C.reset;
 		} else if (g.dstring || g.sstring) {
 			result += C.green + text + C.reset;
+		} else if (g.objKey) {
+			result += C.magenta + text + C.reset;
 		} else if (g.keyword) {
-			result += C.boldBlue + text + C.reset;
+			result += C.keyword + text + C.reset;
 		} else if (g.literal) {
 			result += C.yellow + text + C.reset;
 		} else if (g.typePred) {
 			result += C.cyan + text + C.reset;
 		} else if (g.num) {
 			result += C.cyan + text + C.reset;
+		} else if (g.identifier) {
+			result += C.blue + text + C.reset;
 		} else {
 			result += text;
 		}
@@ -118,7 +171,7 @@ export function highlightRexc(text: string): string {
 				i++;
 				break;
 			case "%": // opcode
-				out += C.boldBlue + prefix + tag + C.reset;
+				out += C.keyword + prefix + tag + C.reset;
 				i++;
 				break;
 			case "$": // variable
@@ -143,6 +196,7 @@ export function highlightRexc(text: string): string {
 				break;
 			}
 			case "=": // assignment
+			case "/": // swap-assign
 			case "~": // delete
 				out += C.red + prefix + tag + C.reset;
 				i++;
@@ -154,11 +208,11 @@ export function highlightRexc(text: string): string {
 			case ">": // for
 			case "<": // for-keys
 			case "#": // while
-				out += C.boldBlue + prefix + tag + C.reset;
+				out += C.keyword + prefix + tag + C.reset;
 				i++;
 				break;
 			case ";": // break/continue
-				out += C.boldBlue + prefix + tag + C.reset;
+				out += C.keyword + prefix + tag + C.reset;
 				i++;
 				break;
 			case "^": // pointer
@@ -180,6 +234,20 @@ export function highlightRexc(text: string): string {
 	return out;
 }
 
+export function highlightAuto(text: string, hint?: "rex" | "rexc"): string {
+	if (hint === "rexc") return highlightRexc(text);
+	if (hint === "rex") return text.split("\n").map((line) => highlightLine(line)).join("\n");
+	try {
+		const match = grammar.match(text);
+		if (match.succeeded()) {
+			return text.split("\n").map((line) => highlightLine(line)).join("\n");
+		}
+	} catch {
+		// fall through
+	}
+	return highlightRexc(text);
+}
+
 // ── JSON IR highlighting ─────────────────────────────────────
 
 const JSON_TOKEN_RE =
@@ -257,26 +325,31 @@ export function isIncomplete(buffer: string): boolean {
 	// Trailing binary operator or keyword suggests continuation
 	const trimmed = buffer.trimEnd();
 	if (/[+\-*/%&|^=<>]$/.test(trimmed)) return true;
-	if (/\b(?:and|or|do|in|of)\s*$/.test(trimmed)) return true;
+	if (/\b(?:and|or|nor|do|in|of)\s*$/.test(trimmed)) return true;
 
 	return false;
 }
 
 // ── Result & state formatting ─────────────────────────────────
 
-function formatResult(value: unknown): string {
+function formatResult(value: unknown, format: OutputFormat): string {
 	let text: string;
 	try {
-		text = stringify(value, { maxWidth: 60 });
+		text = format === "json" ? formatJson(value, 2) : stringify(value, { maxWidth: 60 });
 	} catch {
 		text = String(value);
 	}
-	return `${C.gray}→${C.reset} ${highlightLine(text)}`;
+	const rendered = format === "json" ? highlightJSON(text) : highlightLine(text);
+	return `${C.gray}→${C.reset} ${rendered}`;
 }
 
-export function formatVarState(vars: Record<string, unknown>): string {
+export function formatVarState(vars: Record<string, unknown>, format: OutputFormat): string {
 	const entries = Object.entries(vars);
 	if (entries.length === 0) return "";
+	if (format === "json") {
+		const rendered = highlightJSON(formatJson(vars, 2));
+		return `${C.dim}  vars:${C.reset} ${rendered}`;
+	}
 
 	const MAX_LINE = 70;
 	const MAX_VALUE = 30;
@@ -305,17 +378,58 @@ export function formatVarState(vars: Record<string, unknown>): string {
 	return `${C.dim}  ${parts.join(", ")}${C.reset}`;
 }
 
+function renderValue(value: unknown, format: OutputFormat, kind: OutputKey): string {
+	if (format === "json") {
+		return highlightJSON(formatJson(value, 2));
+	}
+	if (kind === "source") {
+		return highlightAuto(String(value ?? ""));
+	}
+	if (kind === "rexc") {
+		return highlightRexc(String(value ?? ""));
+	}
+	return highlightLine(stringify(value, { maxWidth: 120 }));
+}
+
 // ── Tab completion ────────────────────────────────────────────
 
 const KEYWORDS = [
 	"when", "unless", "while", "for", "do", "end", "in", "of",
-	"and", "or", "else", "break", "continue", "delete",
+	"and", "or", "nor", "else", "break", "continue", "delete",
 	"self", "true", "false", "null", "undefined", "nan", "inf",
 	"string", "number", "object", "array", "boolean",
 ];
 
+const DOT_COMMANDS = [
+	".help",
+	".file",
+	".cat",
+	".expr",
+	".source",
+	".vars",
+	".vars!",
+	".clear",
+	".ir",
+	".rexc",
+	".opt",
+	".json",
+	".color",
+	".exit",
+];
+
 function completer(state: ReplState): (line: string) => [string[], string] {
 	return (line: string) => {
+		if (line.startsWith(".file ")) {
+			return completeFilePath(line, 6);
+		}
+		if (line.startsWith(".cat ")) {
+			return completeFilePath(line, 5);
+		}
+		if (line.startsWith(".") && !line.includes(" ")) {
+			const partial = line.trim();
+			const matches = DOT_COMMANDS.filter((cmd) => cmd.startsWith(partial));
+			return [matches, line];
+		}
 		const match = line.match(/[a-zA-Z_][a-zA-Z0-9_.-]*$/);
 		const partial = match ? match[0] : "";
 		if (!partial) return [[], ""];
@@ -327,9 +441,56 @@ function completer(state: ReplState): (line: string) => [string[], string] {
 	};
 }
 
+function completeFilePath(line: string, prefixLength: number): [string[], string] {
+	const raw = line.slice(prefixLength);
+	const trimmed = raw.trimStart();
+	const quote = trimmed.startsWith("\"") || trimmed.startsWith("'") ? trimmed[0]! : "";
+	const pathPart = quote ? trimmed.slice(1) : trimmed;
+	const endsWithSlash = pathPart.endsWith("/");
+	const rawDir = endsWithSlash ? pathPart.slice(0, -1) : pathPart;
+	const baseName = endsWithSlash ? "" : (rawDir.includes("/") ? basename(rawDir) : rawDir);
+	const dirPart = endsWithSlash ? (rawDir || ".") : (rawDir.includes("/") ? dirname(rawDir) : ".");
+	const dirPath = resolve(dirPart);
+	let entries: string[] = [];
+	try {
+		entries = readdirSync(dirPath);
+	} catch {
+		return [[], ""];
+	}
+	const prefix = dirPart === "." ? "" : `${dirPart}/`;
+	const matches = entries
+		.filter((entry) => entry.startsWith(baseName))
+		.map((entry) => {
+			const fullPath = resolve(dirPath, entry);
+			let suffix = "";
+			try {
+				if (statSync(fullPath).isDirectory()) suffix = "/";
+			} catch {
+				suffix = "";
+			}
+			return `${quote}${prefix}${entry}${suffix}`;
+		});
+	return [matches, trimmed];
+}
+
 // ── Dot commands ──────────────────────────────────────────────
 
-function handleDotCommand(cmd: string, state: ReplState, rl: readline.Interface): boolean {
+function stripQuotes(value: string): string {
+	if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+		return value.slice(1, -1);
+	}
+	return value;
+}
+
+type DotCommandResult = "handled" | "handled-noprompt" | "unhandled";
+
+async function handleDotCommand(
+	cmd: string,
+	state: ReplState,
+	rl: readline.Interface,
+	runSource: (source: string) => void,
+	updatePromptStyles: () => void,
+): Promise<DotCommandResult> {
 	function toggleLabel(on: boolean): string {
 		return on ? `${C.green}on${C.reset}` : `${C.dim}off${C.reset}`;
 	}
@@ -338,42 +499,53 @@ function handleDotCommand(cmd: string, state: ReplState, rl: readline.Interface)
 		case ".help":
 			console.log(
 				[
-					`${C.boldBlue}Rex REPL Commands:${C.reset}`,
-					"  .help   Show this help message",
-					"  .vars   Show all current variables",
-					"  .clear  Clear all variables",
-					"  .ir     Toggle showing IR JSON after parsing",
-					"  .rexc   Toggle showing compiled rexc before execution",
-					"  .opt    Toggle IR optimizations",
-					"  .exit   Exit the REPL",
+					`${C.keyword}Rex REPL Commands:${C.reset}`,
+					"  .help         Show this help message",
+					"  .file <path>  Load and execute a Rex file",
+					"  .cat <path>   Print a Rex/rexc file with highlighting",
+					"  .expr         Toggle showing expression results",
+					"  .source       Toggle showing input source",
+					"  .vars         Toggle showing variable summary",
+					"  .vars!        Show all current variables",
+					"  .clear        Clear all variables",
+					"  .ir           Toggle showing IR JSON after parsing",
+					"  .rexc         Toggle showing compiled rexc before execution",
+					"  .opt          Toggle IR optimizations",
+					"  .json         Toggle JSON output format",
+					"  .color        Toggle ANSI color output",
+					"  .exit         Exit the REPL",
 					"",
 					"Enter Rex expressions to evaluate them.",
 					"Multi-line: open brackets or do/end blocks continue on the next line.",
 					"Ctrl-C cancels multi-line input.",
 					"Ctrl-D exits.",
+					"",
+					"Outputs are printed as labeled blocks when enabled.",
 				].join("\n"),
 			);
-			return true;
+			return "handled";
 
-		case ".ir":
-			state.showIR = !state.showIR;
-			console.log(`${C.dim}  IR display: ${toggleLabel(state.showIR)}${C.reset}`);
-			return true;
+		case ".expr":
+			state.showExpr = !state.showExpr;
+			console.log(`${C.dim}  Expression output: ${toggleLabel(state.showExpr)}${C.reset}`);
+			return "handled";
 
-		case ".rexc":
-			state.showRexc = !state.showRexc;
-			console.log(`${C.dim}  Rexc display: ${toggleLabel(state.showRexc)}${C.reset}`);
-			return true;
+		case ".source":
+			state.showSource = !state.showSource;
+			console.log(`${C.dim}  Source output: ${toggleLabel(state.showSource)}${C.reset}`);
+			return "handled";
 
-		case ".opt":
-			state.optimize = !state.optimize;
-			console.log(`${C.dim}  Optimizations: ${toggleLabel(state.optimize)}${C.reset}`);
-			return true;
+		case ".vars":
+			state.showVars = !state.showVars;
+			console.log(`${C.dim}  Variable summary: ${toggleLabel(state.showVars)}${C.reset}`);
+			return "handled";
 
-		case ".vars": {
+		case ".vars!": {
 			const entries = Object.entries(state.vars);
 			if (entries.length === 0) {
 				console.log(`${C.dim}  (no variables)${C.reset}`);
+			} else if (state.outputFormat === "json") {
+				console.log(highlightJSON(formatJson(state.vars, 2)));
 			} else {
 				for (const [key, val] of entries) {
 					let valStr: string;
@@ -385,25 +557,84 @@ function handleDotCommand(cmd: string, state: ReplState, rl: readline.Interface)
 					console.log(`  ${key} = ${highlightLine(valStr)}`);
 				}
 			}
-			return true;
+			return "handled";
 		}
 
+		case ".ir":
+			state.showIR = !state.showIR;
+			console.log(`${C.dim}  IR display: ${toggleLabel(state.showIR)}${C.reset}`);
+			return "handled";
+
+		case ".rexc":
+			state.showRexc = !state.showRexc;
+			console.log(`${C.dim}  Rexc display: ${toggleLabel(state.showRexc)}${C.reset}`);
+			return "handled";
+
+		case ".opt":
+			state.optimize = !state.optimize;
+			console.log(`${C.dim}  Optimizations: ${toggleLabel(state.optimize)}${C.reset}`);
+			return "handled";
+
+		case ".json":
+			state.outputFormat = state.outputFormat === "json" ? "rex" : "json";
+			console.log(`${C.dim}  Output format: ${state.outputFormat}${C.reset}`);
+			return "handled";
+
+		case ".color":
+			setColorEnabled(!colorEnabled);
+			updatePromptStyles();
+			console.log(`${C.dim}  Color output: ${toggleLabel(colorEnabled)}${C.reset}`);
+			return "handled";
+
 		case ".clear":
 			state.vars = {};
 			state.refs = {};
 			console.log(`${C.dim}  Variables cleared.${C.reset}`);
-			return true;
+			return "handled";
 
 		case ".exit":
 			rl.close();
-			return true;
+			return "handled-noprompt";
 
 		default:
+			if (cmd.startsWith(".cat ")) {
+				const rawPath = cmd.slice(5).trim();
+				if (!rawPath) {
+					console.log(`${C.red}  Missing file path. Usage: .cat <path>${C.reset}`);
+					return "handled";
+				}
+				const filePath = resolve(stripQuotes(rawPath));
+				try {
+					const source = readFileSync(filePath, "utf8");
+					const hint = filePath.endsWith(".rexc") ? "rexc" : filePath.endsWith(".rex") ? "rex" : undefined;
+					console.log(highlightAuto(source, hint));
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					console.log(`${C.red}  File error: ${message}${C.reset}`);
+				}
+				return "handled";
+			}
+			if (cmd.startsWith(".file ")) {
+				const rawPath = cmd.slice(6).trim();
+				if (!rawPath) {
+					console.log(`${C.red}  Missing file path. Usage: .file <path>${C.reset}`);
+					return "handled";
+				}
+				const filePath = resolve(stripQuotes(rawPath));
+				try {
+					const source = readFileSync(filePath, "utf8");
+					runSource(source);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					console.log(`${C.red}  File error: ${message}${C.reset}`);
+				}
+				return "handled";
+			}
 			if (cmd.startsWith(".")) {
 				console.log(`${C.red}  Unknown command: ${cmd}. Type .help for available commands.${C.reset}`);
-				return true;
+				return "handled";
 			}
-			return false;
+			return "unhandled";
 	}
 }
 
@@ -415,37 +646,72 @@ type ReplState = {
 	showIR: boolean;
 	showRexc: boolean;
 	optimize: boolean;
+	showExpr: boolean;
+	showVars: boolean;
+	showSource: boolean;
+	outputFormat: OutputFormat;
 };
 
+type OutputKey = "source" | "ir" | "rexc" | "vars" | "result";
+
 // ── Gas limit for loop safety ─────────────────────────────────
 
 const GAS_LIMIT = 10_000_000;
+const HISTORY_LIMIT = 1000;
+const HISTORY_PATH = resolve(homedir(), ".rex_history");
 
 // ── Main REPL entry point ─────────────────────────────────────
 
 export async function startRepl(): Promise<void> {
-	const state: ReplState = { vars: {}, refs: {}, showIR: false, showRexc: false, optimize: false };
+	const state: ReplState = {
+		vars: {},
+		refs: {},
+		showIR: false,
+		showRexc: false,
+		optimize: false,
+		showExpr: true,
+		showVars: false,
+		showSource: false,
+		outputFormat: "rex",
+	};
 	let multiLineBuffer = "";
 
 	const PRIMARY_PROMPT = "rex> ";
 	const CONT_PROMPT = "...  ";
-	const STYLED_PRIMARY = `${C.boldBlue}rex${C.reset}> `;
-	const STYLED_CONT = `${C.dim}...${C.reset}  `;
 
 	let currentPrompt = PRIMARY_PROMPT;
-	let styledPrompt = STYLED_PRIMARY;
+	let styledPrompt = "";
+	let styledPrimary = "";
+	let styledCont = "";
+
+	function updatePromptStyles() {
+		styledPrimary = `${C.keyword}rex${C.reset}> `;
+		styledCont = `${C.dim}...${C.reset}  `;
+		styledPrompt = currentPrompt === PRIMARY_PROMPT ? styledPrimary : styledCont;
+	}
+
+	updatePromptStyles();
 
-	console.log(`${C.boldBlue}Rex${C.reset} v${version} — type ${C.dim}.help${C.reset} for commands`);
+	console.log(`${C.keyword}Rex${C.reset} v${version} — type ${C.dim}.help${C.reset} for commands`);
 
 	const rl = readline.createInterface({
 		input: process.stdin,
 		output: process.stdout,
 		prompt: PRIMARY_PROMPT,
-		historySize: 500,
+		historySize: HISTORY_LIMIT,
 		completer: completer(state),
 		terminal: true,
 	});
 
+	try {
+		const historyText = readFileSync(HISTORY_PATH, "utf8");
+		const lines = historyText.split(/\r?\n/).filter((line) => line.trim().length > 0);
+		const recent = lines.slice(-HISTORY_LIMIT);
+		(rl as readline.Interface & { history: string[] }).history = recent.reverse();
+	} catch {
+		// ignore missing history
+	}
+
 	// ── Syntax highlighting via keypress redraw ──
 	process.stdin.on("keypress", () => {
 		process.nextTick(() => {
@@ -473,7 +739,7 @@ export async function startRepl(): Promise<void> {
 		if (multiLineBuffer) {
 			multiLineBuffer = "";
 			currentPrompt = PRIMARY_PROMPT;
-			styledPrompt = STYLED_PRIMARY;
+			styledPrompt = styledPrimary;
 			rl.setPrompt(PRIMARY_PROMPT);
 			process.stdout.write("\n");
 			rl.prompt();
@@ -485,21 +751,72 @@ export async function startRepl(): Promise<void> {
 
 	function resetPrompt() {
 		currentPrompt = PRIMARY_PROMPT;
-		styledPrompt = STYLED_PRIMARY;
+		styledPrompt = styledPrimary;
 		rl.setPrompt(PRIMARY_PROMPT);
 		rl.prompt();
 	}
 
 	// ── Line handler ──
-	rl.on("line", (line: string) => {
+	function runSource(source: string) {
+		const match = grammar.match(source);
+		if (!match.succeeded()) {
+			const message = formatParseError(source, match as { message?: string; getRightmostFailurePosition?: () => number });
+			console.log(`${C.red}  ${message}${C.reset}`);
+			return;
+		}
+
+		try {
+			const outputs: Partial<Record<OutputKey, unknown>> = {};
+			if (state.showSource) outputs.source = source;
+			const isRex = grammar.match(source).succeeded();
+			if (!isRex && state.showIR) {
+				console.log(`${C.red}  IR output is only available for Rex source.${C.reset}`);
+			}
+			const rexc = isRex ? compile(source, { optimize: state.optimize }) : source;
+			if (state.showIR && isRex) {
+				const ir = parseToIR(source);
+				const lowered = state.optimize ? optimizeIR(ir) : ir;
+				outputs.ir = lowered;
+			}
+			if (state.showRexc) outputs.rexc = rexc;
+
+			const result = evaluateRexc(rexc, {
+				vars: { ...state.vars },
+				refs: { ...state.refs },
+				gasLimit: GAS_LIMIT,
+			});
+			state.vars = result.state.vars;
+			state.refs = result.state.refs;
+			if (state.showExpr) outputs.result = result.value;
+			if (state.showVars) outputs.vars = state.vars;
+
+			const order: OutputKey[] = ["source", "ir", "rexc", "vars", "result"];
+			for (const key of order) {
+				const value = outputs[key];
+				if (value === undefined) continue;
+				console.log(`${C.gray}  ${key}:${C.reset} ${renderValue(value, state.outputFormat, key)}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message.includes("Gas limit exceeded")) {
+				console.log(`${C.yellow}  ${message}${C.reset}`);
+			} else {
+				console.log(`${C.red}  Error: ${message}${C.reset}`);
+			}
+		}
+	}
+
+	rl.on("line", async (line: string) => {
 		const trimmed = line.trim();
 
 		// Dot commands (only when not accumulating multi-line)
 		if (!multiLineBuffer && trimmed.startsWith(".")) {
-			if (handleDotCommand(trimmed, state, rl)) {
+			const result = await handleDotCommand(trimmed, state, rl, runSource, updatePromptStyles);
+			if (result === "handled") {
 				rl.prompt();
 				return;
 			}
+			if (result === "handled-noprompt") return;
 		}
 
 		// Accumulate
@@ -515,7 +832,7 @@ export async function startRepl(): Promise<void> {
 		// Check for incomplete expression
 		if (isIncomplete(multiLineBuffer)) {
 			currentPrompt = CONT_PROMPT;
-			styledPrompt = STYLED_CONT;
+			styledPrompt = styledCont;
 			rl.setPrompt(CONT_PROMPT);
 			rl.prompt();
 			return;
@@ -525,52 +842,24 @@ export async function startRepl(): Promise<void> {
 		const source = multiLineBuffer;
 		multiLineBuffer = "";
 
-		const match = grammar.match(source);
-		if (!match.succeeded()) {
-			console.log(`${C.red}  ${match.message}${C.reset}`);
-			resetPrompt();
-			return;
-		}
-
-		try {
-			const ir = parseToIR(source);
-			const lowered = state.optimize ? optimizeIR(ir) : ir;
-
-			if (state.showIR) {
-				console.log(`${C.dim}  IR:${C.reset} ${highlightJSON(JSON.stringify(lowered))}`);
-			}
-
-			const rexc = compile(source, { optimize: state.optimize });
-
-			if (state.showRexc) {
-				console.log(`${C.dim}  rexc:${C.reset} ${highlightRexc(rexc)}`);
-			}
-
-			const result = evaluateRexc(rexc, {
-				vars: { ...state.vars },
-				refs: { ...state.refs },
-				gasLimit: GAS_LIMIT,
-			});
-			state.vars = result.state.vars;
-			state.refs = result.state.refs;
-
-			console.log(formatResult(result.value));
-			const varLine = formatVarState(state.vars);
-			if (varLine) console.log(varLine);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			if (message.includes("Gas limit exceeded")) {
-				console.log(`${C.yellow}  ${message}${C.reset}`);
-			} else {
-				console.log(`${C.red}  Error: ${message}${C.reset}`);
-			}
-		}
+		runSource(source);
 
 		resetPrompt();
 	});
 
 	// ── Exit ──
 	rl.on("close", () => {
+		try {
+			const history = (rl as readline.Interface & { history: string[] }).history ?? [];
+			const trimmed = history
+				.slice()
+				.reverse()
+				.filter((line) => line.trim().length > 0)
+				.slice(-HISTORY_LIMIT);
+			writeFileSync(HISTORY_PATH, `${trimmed.join("\n")}\n`, "utf8");
+		} catch {
+			// ignore history write errors
+		}
 		process.exit(0);
 	});