@isl-lang/repl 0.0.1 → 0.1.1

package/dist/index.js

@@ -0,0 +1,2228 @@
+import * as readline from 'readline';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var Session = class {
+  /** Defined intents in this session */
+  intents = /* @__PURE__ */ new Map();
+  /** Variables set during the session */
+  variables = /* @__PURE__ */ new Map();
+  /** Command history */
+  history = [];
+  /** Last evaluation result */
+  lastResult = void 0;
+  /** Loaded files */
+  loadedFiles = /* @__PURE__ */ new Set();
+  /** Session configuration */
+  config;
+  /** Evaluation context (set by .context command) */
+  evalContext = {};
+  /** Pre-state context for old() expressions */
+  preContext = null;
+  /** Loaded domain AST (from real parser) */
+  domainAST = null;
+  constructor(config = {}) {
+    this.config = {
+      colors: true,
+      verbose: false,
+      cwd: process.cwd(),
+      ...config
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Intent Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Define a new intent
+   */
+  defineIntent(intent) {
+    this.intents.set(intent.name, intent);
+  }
+  /**
+   * Get an intent by name
+   */
+  getIntent(name) {
+    return this.intents.get(name);
+  }
+  /**
+   * Get all defined intents
+   */
+  getAllIntents() {
+    return Array.from(this.intents.values());
+  }
+  /**
+   * Check if an intent exists
+   */
+  hasIntent(name) {
+    return this.intents.has(name);
+  }
+  /**
+   * Remove an intent
+   */
+  removeIntent(name) {
+    return this.intents.delete(name);
+  }
+  /**
+   * Get intent names for completion
+   */
+  getIntentNames() {
+    return Array.from(this.intents.keys());
+  }
+  /**
+   * Parse an intent definition from source code
+   */
+  parseIntent(source) {
+    const trimmed = source.trim();
+    const match = trimmed.match(/^intent\s+(\w+)\s*\{([\s\S]*)\}$/);
+    if (!match) {
+      return null;
+    }
+    const name = match[1];
+    const body = match[2];
+    const intent = {
+      name,
+      preconditions: [],
+      postconditions: [],
+      invariants: [],
+      scenarios: [],
+      rawSource: source
+    };
+    const preMatch = body.match(/pre(?:conditions?)?\s*:\s*([^\n]+)/g);
+    if (preMatch) {
+      for (const pre of preMatch) {
+        const expr = pre.replace(/pre(?:conditions?)?\s*:\s*/, "").trim();
+        if (expr) {
+          intent.preconditions.push({ expression: expr });
+        }
+      }
+    }
+    const postMatch = body.match(/post(?:conditions?)?\s*:\s*([^\n]+)/g);
+    if (postMatch) {
+      for (const post of postMatch) {
+        const expr = post.replace(/post(?:conditions?)?\s*:\s*/, "").trim();
+        if (expr) {
+          intent.postconditions.push({ expression: expr });
+        }
+      }
+    }
+    const invMatch = body.match(/invariants?\s*:\s*([^\n]+)/g);
+    if (invMatch) {
+      for (const inv of invMatch) {
+        const expr = inv.replace(/invariants?\s*:\s*/, "").trim();
+        if (expr) {
+          intent.invariants.push({ expression: expr });
+        }
+      }
+    }
+    return intent;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Variable Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Set a variable
+   */
+  setVariable(name, value) {
+    this.variables.set(name, value);
+  }
+  /**
+   * Get a variable
+   */
+  getVariable(name) {
+    return this.variables.get(name);
+  }
+  /**
+   * Get all variables
+   */
+  getAllVariables() {
+    return new Map(this.variables);
+  }
+  /**
+   * Check if a variable exists
+   */
+  hasVariable(name) {
+    return this.variables.has(name);
+  }
+  /**
+   * Set the last result (accessible as _)
+   */
+  setLastResult(value) {
+    this.lastResult = value;
+    this.variables.set("_", value);
+  }
+  /**
+   * Get the last result
+   */
+  getLastResult() {
+    return this.lastResult;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // History Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Add to history
+   */
+  addToHistory(entry) {
+    const trimmed = entry.trim();
+    if (trimmed && (this.history.length === 0 || this.history[this.history.length - 1] !== trimmed)) {
+      this.history.push(trimmed);
+    }
+  }
+  /**
+   * Get history
+   */
+  getHistory(count) {
+    if (count) {
+      return this.history.slice(-count);
+    }
+    return [...this.history];
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // File Loading
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Load intents from an ISL file
+   */
+  async loadFile(filePath) {
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(this.config.cwd, filePath);
+    if (!fs2.existsSync(resolvedPath)) {
+      return { intents: [], errors: [`File not found: ${resolvedPath}`] };
+    }
+    try {
+      const content = fs2.readFileSync(resolvedPath, "utf-8");
+      const loadedIntents = [];
+      const errors = [];
+      const intentRegex = /intent\s+(\w+)\s*\{[^}]*(?:\{[^}]*\}[^}]*)*\}/g;
+      let match;
+      while ((match = intentRegex.exec(content)) !== null) {
+        const intent = this.parseIntent(match[0]);
+        if (intent) {
+          this.defineIntent(intent);
+          loadedIntents.push(intent);
+        } else {
+          errors.push(`Failed to parse intent starting at position ${match.index}`);
+        }
+      }
+      const behaviorRegex = /behavior\s+(\w+)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+      while ((match = behaviorRegex.exec(content)) !== null) {
+        const intent = this.parseBehaviorAsIntent(match[1], match[2]);
+        if (intent) {
+          this.defineIntent(intent);
+          loadedIntents.push(intent);
+        }
+      }
+      this.loadedFiles.add(resolvedPath);
+      return { intents: loadedIntents, errors };
+    } catch (error) {
+      return {
+        intents: [],
+        errors: [`Failed to load file: ${error instanceof Error ? error.message : String(error)}`]
+      };
+    }
+  }
+  /**
+   * Parse a behavior block as an intent
+   */
+  parseBehaviorAsIntent(name, body) {
+    const intent = {
+      name,
+      preconditions: [],
+      postconditions: [],
+      invariants: [],
+      scenarios: [],
+      rawSource: `behavior ${name} {${body}}`
+    };
+    const preSection = body.match(/pre(?:conditions)?\s*\{([^}]*)\}/s);
+    if (preSection) {
+      const conditions = preSection[1].trim().split("\n").map((l) => l.trim()).filter(Boolean);
+      for (const cond of conditions) {
+        const expr = cond.replace(/^-\s*/, "").trim();
+        if (expr) {
+          intent.preconditions.push({ expression: expr });
+        }
+      }
+    }
+    const postSection = body.match(/post(?:conditions)?\s*\{([^}]*)\}/s);
+    if (postSection) {
+      const conditions = postSection[1].trim().split("\n").map((l) => l.trim()).filter(Boolean);
+      for (const cond of conditions) {
+        const expr = cond.replace(/^-\s*/, "").trim();
+        if (expr) {
+          intent.postconditions.push({ expression: expr });
+        }
+      }
+    }
+    const invSection = body.match(/invariants?\s*\{([^}]*)\}/s);
+    if (invSection) {
+      const conditions = invSection[1].trim().split("\n").map((l) => l.trim()).filter(Boolean);
+      for (const cond of conditions) {
+        const expr = cond.replace(/^-\s*/, "").trim();
+        if (expr) {
+          intent.invariants.push({ expression: expr });
+        }
+      }
+    }
+    return intent;
+  }
+  /**
+   * Export session intents to a file
+   */
+  async exportToFile(filePath) {
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(this.config.cwd, filePath);
+    try {
+      const lines = [];
+      lines.push("// Exported ISL intents");
+      lines.push(`// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+      lines.push("");
+      for (const intent of this.intents.values()) {
+        lines.push(`intent ${intent.name} {`);
+        for (const pre of intent.preconditions) {
+          lines.push(`  pre: ${pre.expression}`);
+        }
+        for (const post of intent.postconditions) {
+          lines.push(`  post: ${post.expression}`);
+        }
+        for (const inv of intent.invariants) {
+          lines.push(`  invariant: ${inv.expression}`);
+        }
+        lines.push("}");
+        lines.push("");
+      }
+      fs2.writeFileSync(resolvedPath, lines.join("\n"));
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to export: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Evaluation Context Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Set evaluation context from JSON string
+   */
+  setEvalContext(json) {
+    try {
+      const parsed = JSON.parse(json);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return { success: false, count: 0, error: "Context must be a JSON object" };
+      }
+      this.evalContext = parsed;
+      for (const [key, value] of Object.entries(this.evalContext)) {
+        this.variables.set(key, value);
+      }
+      return { success: true, count: Object.keys(parsed).length };
+    } catch (e) {
+      return { success: false, count: 0, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  /**
+   * Set pre-state context for old() expressions
+   */
+  setPreContext(json) {
+    try {
+      const parsed = JSON.parse(json);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return { success: false, error: "Pre-context must be a JSON object" };
+      }
+      this.preContext = parsed;
+      return { success: true };
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  /**
+   * Get evaluation context
+   */
+  getEvalContext() {
+    return { ...this.evalContext };
+  }
+  /**
+   * Get pre-state context
+   */
+  getPreContext() {
+    return this.preContext ? { ...this.preContext } : null;
+  }
+  /**
+   * Resolve a dot-path against the evaluation context
+   */
+  resolveValue(dotPath) {
+    const parts = dotPath.split(".");
+    let current = this.evalContext;
+    for (const part of parts) {
+      if (current === null || current === void 0 || typeof current !== "object") {
+        return { found: false, value: void 0 };
+      }
+      current = current[part];
+    }
+    return { found: current !== void 0, value: current };
+  }
+  /**
+   * Resolve a dot-path against the pre-state context
+   */
+  resolvePreValue(dotPath) {
+    if (!this.preContext) {
+      return { found: false, value: void 0 };
+    }
+    const parts = dotPath.split(".");
+    let current = this.preContext;
+    for (const part of parts) {
+      if (current === null || current === void 0 || typeof current !== "object") {
+        return { found: false, value: void 0 };
+      }
+      current = current[part];
+    }
+    return { found: current !== void 0, value: current };
+  }
+  /**
+   * Set domain AST (from real parser)
+   */
+  setDomainAST(ast) {
+    this.domainAST = ast;
+  }
+  /**
+   * Get domain AST
+   */
+  getDomainAST() {
+    return this.domainAST;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Clear all session state
+   */
+  clear() {
+    this.intents.clear();
+    this.variables.clear();
+    this.lastResult = void 0;
+    this.loadedFiles.clear();
+    this.evalContext = {};
+    this.preContext = null;
+    this.domainAST = null;
+  }
+  /**
+   * Get session summary
+   */
+  getSummary() {
+    return {
+      intentCount: this.intents.size,
+      variableCount: this.variables.size,
+      loadedFileCount: this.loadedFiles.size,
+      historyCount: this.history.length
+    };
+  }
+  /**
+   * Get loaded files
+   */
+  getLoadedFiles() {
+    return Array.from(this.loadedFiles);
+  }
+  /**
+   * Get config
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update config
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+function createSession(config) {
+  return new Session(config);
+}
+var History = class {
+  entries = [];
+  position = -1;
+  maxSize;
+  historyFile;
+  unsavedCount = 0;
+  autoSaveThreshold = 10;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 1e3;
+    this.historyFile = options.historyFile ?? this.getDefaultHistoryFile();
+    this.autoSaveThreshold = options.autoSaveThreshold ?? 10;
+  }
+  /**
+   * Get default history file path
+   */
+  getDefaultHistoryFile() {
+    const homeDir = os.homedir();
+    return path.join(homeDir, ".isl_repl_history");
+  }
+  /**
+   * Load history from file
+   */
+  load() {
+    try {
+      if (fs2.existsSync(this.historyFile)) {
+        const content = fs2.readFileSync(this.historyFile, "utf-8");
+        this.entries = content.split("\n").filter((line) => line.trim() !== "").slice(-this.maxSize);
+        this.position = this.entries.length;
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save history to file
+   */
+  save() {
+    try {
+      const dir = path.dirname(this.historyFile);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+      fs2.writeFileSync(this.historyFile, this.entries.join("\n") + "\n");
+      this.unsavedCount = 0;
+    } catch {
+    }
+  }
+  /**
+   * Add entry to history
+   */
+  add(entry) {
+    const trimmed = entry.trim();
+    if (trimmed === "") return;
+    if (this.entries.length > 0 && this.entries[this.entries.length - 1] === trimmed) {
+      this.position = this.entries.length;
+      return;
+    }
+    this.entries.push(trimmed);
+    if (this.entries.length > this.maxSize) {
+      this.entries = this.entries.slice(-this.maxSize);
+    }
+    this.position = this.entries.length;
+    this.unsavedCount++;
+    if (this.unsavedCount >= this.autoSaveThreshold) {
+      this.save();
+    }
+  }
+  /**
+   * Get previous entry (for up arrow)
+   */
+  previous() {
+    if (this.entries.length === 0) return null;
+    if (this.position > 0) {
+      this.position--;
+    }
+    return this.entries[this.position] ?? null;
+  }
+  /**
+   * Get next entry (for down arrow)
+   */
+  next() {
+    if (this.entries.length === 0) return null;
+    if (this.position < this.entries.length - 1) {
+      this.position++;
+      return this.entries[this.position] ?? null;
+    }
+    this.position = this.entries.length;
+    return "";
+  }
+  /**
+   * Reset position to end
+   */
+  resetPosition() {
+    this.position = this.entries.length;
+  }
+  /**
+   * Search history for entries containing text
+   */
+  search(text) {
+    const lower = text.toLowerCase();
+    return this.entries.filter(
+      (entry) => entry.toLowerCase().includes(lower)
+    );
+  }
+  /**
+   * Search backwards from current position
+   */
+  searchBackward(text) {
+    const lower = text.toLowerCase();
+    for (let i = this.position - 1; i >= 0; i--) {
+      if (this.entries[i].toLowerCase().includes(lower)) {
+        this.position = i;
+        return this.entries[i];
+      }
+    }
+    return null;
+  }
+  /**
+   * Search forward from current position
+   */
+  searchForward(text) {
+    const lower = text.toLowerCase();
+    for (let i = this.position + 1; i < this.entries.length; i++) {
+      if (this.entries[i].toLowerCase().includes(lower)) {
+        this.position = i;
+        return this.entries[i];
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all entries
+   */
+  getAll() {
+    return [...this.entries];
+  }
+  /**
+   * Get recent entries
+   */
+  getRecent(count) {
+    return this.entries.slice(-count);
+  }
+  /**
+   * Clear history
+   */
+  clear() {
+    this.entries = [];
+    this.position = 0;
+    this.save();
+  }
+  /**
+   * Get history size
+   */
+  get size() {
+    return this.entries.length;
+  }
+  /**
+   * Get current position
+   */
+  get currentPosition() {
+    return this.position;
+  }
+};
+var MemoryHistory = class extends History {
+  constructor(maxSize = 1e3) {
+    super({ maxSize, historyFile: "" });
+  }
+  load() {
+  }
+  save() {
+  }
+};
+
+// src/formatter.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  // Foreground colors
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Bright foreground
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  // Background colors
+  bgBlack: "\x1B[40m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m"
+};
+function formatSuccess(message) {
+  return `${colors.green}\u2713${colors.reset} ${message}`;
+}
+function formatError(message) {
+  return `${colors.red}\u2717 Error:${colors.reset} ${message}`;
+}
+function formatWarning(message) {
+  return `${colors.yellow}\u26A0${colors.reset} ${message}`;
+}
+function formatInfo(message) {
+  return `${colors.cyan}\u2139${colors.reset} ${message}`;
+}
+function formatIntent(intent) {
+  const lines = [
+    "",
+    `${colors.bold}Intent: ${colors.cyan}${intent.name}${colors.reset}`,
+    colors.gray + "\u2500".repeat(40) + colors.reset
+  ];
+  if (intent.preconditions.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Preconditions:${colors.reset}`);
+    for (const pre of intent.preconditions) {
+      lines.push(`  ${colors.magenta}pre:${colors.reset} ${highlightExpression(pre.expression)}`);
+    }
+  }
+  if (intent.postconditions.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Postconditions:${colors.reset}`);
+    for (const post of intent.postconditions) {
+      lines.push(`  ${colors.magenta}post:${colors.reset} ${highlightExpression(post.expression)}`);
+    }
+  }
+  if (intent.invariants.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Invariants:${colors.reset}`);
+    for (const inv of intent.invariants) {
+      lines.push(`  ${colors.magenta}invariant:${colors.reset} ${highlightExpression(inv.expression)}`);
+    }
+  }
+  if (intent.scenarios.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Scenarios:${colors.reset}`);
+    for (const scenario of intent.scenarios) {
+      lines.push(`  ${colors.yellow}${scenario.name}${colors.reset}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatCondition(condition, type) {
+  const prefix = {
+    pre: colors.magenta + "pre" + colors.reset,
+    post: colors.magenta + "post" + colors.reset,
+    invariant: colors.magenta + "invariant" + colors.reset
+  }[type];
+  return `${prefix}: ${highlightExpression(condition.expression)}`;
+}
+function highlightExpression(expr) {
+  return expr.replace(/\b(and|or|not|implies)\b/g, `${colors.yellow}$1${colors.reset}`).replace(/(>=|<=|==|!=|>|<)/g, `${colors.yellow}$1${colors.reset}`).replace(/\b(true|false|null)\b/g, `${colors.magenta}$1${colors.reset}`).replace(/\b(forall|exists|in)\b/g, `${colors.yellow}$1${colors.reset}`).replace(/\b(\d+(?:\.\d+)?)\b/g, `${colors.cyan}$1${colors.reset}`).replace(/"([^"]*)"/g, `${colors.green}"$1"${colors.reset}`).replace(/\.(\w+)\(/g, `.${colors.blue}$1${colors.reset}(`).replace(/\.(\w+)(?!\()/g, `.${colors.cyan}$1${colors.reset}`);
+}
+function highlightISL(source) {
+  return source.replace(/\b(intent|behavior|entity|domain|type|enum)\b/g, `${colors.yellow}$1${colors.reset}`).replace(/\b(pre|post|invariant|scenario)\b/g, `${colors.magenta}$1${colors.reset}`).replace(/\b(input|output|success|errors?)\b/g, `${colors.blue}$1${colors.reset}`).replace(
+    /\b(String|Int|Boolean|UUID|Timestamp|Decimal|Duration|List|Map|Optional)\b/g,
+    `${colors.green}$1${colors.reset}`
+  ).replace(/\b(and|or|not|implies|forall|exists|in)\b/g, `${colors.yellow}$1${colors.reset}`).replace(/\b(true|false|null)\b/g, `${colors.magenta}$1${colors.reset}`).replace(/\b(\d+(?:\.\d+)?)\b/g, `${colors.cyan}$1${colors.reset}`).replace(/"([^"]*)"/g, `${colors.green}"$1"${colors.reset}`).replace(/(\/\/[^\n]*)/g, `${colors.gray}$1${colors.reset}`).replace(/(#[^\n]*)/g, `${colors.gray}$1${colors.reset}`);
+}
+function formatTable(headers, rows, options = {}) {
+  const useColors = options.colors !== false;
+  const widths = headers.map((h, i) => {
+    const cellWidths = [h.length, ...rows.map((r) => (r[i] ?? "").length)];
+    return Math.max(...cellWidths);
+  });
+  const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join(" \u2502 ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500");
+  const dataRows = rows.map(
+    (row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join(" \u2502 ")
+  );
+  const headerFormatted = useColors ? `${colors.bold}${headerRow}${colors.reset}` : headerRow;
+  const sepFormatted = useColors ? `${colors.gray}${separator}${colors.reset}` : separator;
+  return [headerFormatted, sepFormatted, ...dataRows].join("\n");
+}
+function formatParseError(source, message, line, column) {
+  const lines = source.split("\n");
+  const errorLine = lines[line - 1] || "";
+  const output = [
+    formatError(message),
+    "",
+    `${colors.gray}${String(line).padStart(4)} \u2502${colors.reset} ${errorLine}`,
+    `${colors.gray}     \u2502${colors.reset} ${" ".repeat(column - 1)}${colors.red}^${colors.reset}`
+  ];
+  return output.join("\n");
+}
+function formatTypeError(message, expected, actual, context) {
+  const output = [
+    formatError(message),
+    "",
+    `  Expected: ${colors.green}${expected}${colors.reset}`,
+    `  Actual:   ${colors.red}${actual}${colors.reset}`
+  ];
+  if (context) {
+    output.push("");
+    output.push(`  Context: ${colors.gray}${context}${colors.reset}`);
+  }
+  return output.join("\n");
+}
+function formatValue(value, indent = 0) {
+  const pad = " ".repeat(indent);
+  if (value === null) return `${colors.gray}null${colors.reset}`;
+  if (value === void 0) return `${colors.gray}undefined${colors.reset}`;
+  if (typeof value === "string") {
+    return `${colors.green}"${value}"${colors.reset}`;
+  }
+  if (typeof value === "number") {
+    return `${colors.cyan}${value}${colors.reset}`;
+  }
+  if (typeof value === "boolean") {
+    return `${colors.magenta}${value}${colors.reset}`;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((v) => formatValue(v, indent + 2));
+    return `[
+${pad}  ${items.join(`,
+${pad}  `)}
+${pad}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const items = entries.map(
+      ([k, v]) => `${colors.blue}${k}${colors.reset}: ${formatValue(v, indent + 2)}`
+    );
+    return `{
+${pad}  ${items.join(`,
+${pad}  `)}
+${pad}}`;
+  }
+  return String(value);
+}
+function stripColors(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function wrapText(text, maxWidth) {
+  const words = text.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    const testLine = currentLine ? `${currentLine} ${word}` : word;
+    if (stripColors(testLine).length > maxWidth && currentLine) {
+      lines.push(currentLine);
+      currentLine = word;
+    } else {
+      currentLine = testLine;
+    }
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  return lines.join("\n");
+}
+function drawBox(lines, title) {
+  const maxLen = Math.max(...lines.map((l) => stripColors(l).length), title ? title.length + 4 : 0);
+  const top = title ? `\u2554\u2550 ${title} ${"\u2550".repeat(maxLen - title.length - 3)}\u2557` : `\u2554${"\u2550".repeat(maxLen + 2)}\u2557`;
+  const bottom = `\u255A${"\u2550".repeat(maxLen + 2)}\u255D`;
+  const paddedLines = lines.map((l) => {
+    const padding = maxLen - stripColors(l).length;
+    return `\u2551 ${l}${" ".repeat(padding)} \u2551`;
+  });
+  return [top, ...paddedLines, bottom].join("\n");
+}
+
+// src/commands.ts
+function evaluateExpression(expr, session) {
+  const trimmed = expr.trim();
+  const oldMatch = trimmed.match(/^old\((.+)\)$/);
+  if (oldMatch) {
+    const innerPath = oldMatch[1].trim();
+    if (!session.getPreContext()) {
+      return {
+        value: void 0,
+        error: "old() requires pre-state. Set with .context --pre <json>"
+      };
+    }
+    const { found, value } = session.resolvePreValue(innerPath);
+    if (!found) {
+      return { value: void 0, error: `Cannot resolve '${innerPath}' in pre-state context` };
+    }
+    return { value };
+  }
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    return evaluateExpression(trimmed.slice(1, -1), session);
+  }
+  if (trimmed.startsWith("!") || trimmed.startsWith("not ")) {
+    const inner = trimmed.startsWith("!") ? trimmed.slice(1) : trimmed.slice(4);
+    const result = evaluateExpression(inner.trim(), session);
+    if (result.error) return result;
+    return { value: !result.value };
+  }
+  for (const [opStr, opFn] of BINARY_OPS) {
+    const idx = findOperator(trimmed, opStr);
+    if (idx !== -1) {
+      const left = trimmed.slice(0, idx).trim();
+      const right = trimmed.slice(idx + opStr.length).trim();
+      const lResult = evaluateExpression(left, session);
+      if (lResult.error) return lResult;
+      const rResult = evaluateExpression(right, session);
+      if (rResult.error) return rResult;
+      return { value: opFn(lResult.value, rResult.value) };
+    }
+  }
+  if (trimmed === "true") return { value: true };
+  if (trimmed === "false") return { value: false };
+  if (trimmed === "null") return { value: null };
+  if (/^-?\d+$/.test(trimmed)) return { value: parseInt(trimmed, 10) };
+  if (/^-?\d+\.\d+$/.test(trimmed)) return { value: parseFloat(trimmed) };
+  if (/^"([^"]*)"$/.test(trimmed)) return { value: trimmed.slice(1, -1) };
+  if (/^'([^']*)'$/.test(trimmed)) return { value: trimmed.slice(1, -1) };
+  if (/^[\w.]+$/.test(trimmed)) {
+    const { found, value } = session.resolveValue(trimmed);
+    if (found) return { value };
+    if (session.hasVariable(trimmed)) {
+      return { value: session.getVariable(trimmed) };
+    }
+  }
+  return { value: void 0, error: `Cannot evaluate: ${trimmed}` };
+}
+var BINARY_OPS = [
+  // Logical (lowest precedence — scanned first so they split outermost)
+  [" || ", (a, b) => Boolean(a) || Boolean(b)],
+  [" or ", (a, b) => Boolean(a) || Boolean(b)],
+  [" && ", (a, b) => Boolean(a) && Boolean(b)],
+  [" and ", (a, b) => Boolean(a) && Boolean(b)],
+  // Equality
+  [" == ", (a, b) => a === b || String(a) === String(b)],
+  [" != ", (a, b) => a !== b && String(a) !== String(b)],
+  // Comparison
+  [" >= ", (a, b) => Number(a) >= Number(b)],
+  [" <= ", (a, b) => Number(a) <= Number(b)],
+  [" > ", (a, b) => Number(a) > Number(b)],
+  [" < ", (a, b) => Number(a) < Number(b)],
+  // Arithmetic
+  [" + ", (a, b) => {
+    if (typeof a === "string" || typeof b === "string") return String(a) + String(b);
+    return Number(a) + Number(b);
+  }],
+  [" - ", (a, b) => Number(a) - Number(b)],
+  [" * ", (a, b) => Number(a) * Number(b)],
+  [" / ", (a, b) => {
+    const d = Number(b);
+    if (d === 0) return Infinity;
+    return Number(a) / d;
+  }]
+];
+function findOperator(expr, op) {
+  let depth = 0;
+  let inString = null;
+  for (let i = expr.length - 1; i >= 0; i--) {
+    const ch = expr[i];
+    if (inString) {
+      if (ch === inString && (i === 0 || expr[i - 1] !== "\\")) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "(") depth--;
+    if (ch === ")") depth++;
+    if (depth === 0 && i + op.length <= expr.length && expr.slice(i, i + op.length) === op) {
+      return i;
+    }
+  }
+  return -1;
+}
+function prettyPrintAST(node, indent = 0) {
+  const pad = "  ".repeat(indent);
+  if (node === null || node === void 0) return `${pad}${colors.gray}null${colors.reset}`;
+  if (typeof node === "string") return `${pad}${colors.green}"${node}"${colors.reset}`;
+  if (typeof node === "number") return `${pad}${colors.cyan}${node}${colors.reset}`;
+  if (typeof node === "boolean") return `${pad}${colors.magenta}${node}${colors.reset}`;
+  if (Array.isArray(node)) {
+    if (node.length === 0) return `${pad}[]`;
+    const items = node.map((item) => prettyPrintAST(item, indent + 1));
+    return `${pad}[
+${items.join(",\n")}
+${pad}]`;
+  }
+  if (typeof node === "object") {
+    const obj = node;
+    const kind = obj["kind"];
+    const entries = Object.entries(obj).filter(
+      ([k, v]) => k !== "location" && v !== void 0 && !(Array.isArray(v) && v.length === 0)
+    );
+    if (entries.length === 0) return `${pad}{}`;
+    const header = kind ? `${pad}${colors.yellow}${kind}${colors.reset} {` : `${pad}{`;
+    const body = entries.filter(([k]) => k !== "kind").map(([k, v]) => {
+      const valStr = typeof v === "object" && v !== null ? "\n" + prettyPrintAST(v, indent + 2) : " " + prettyPrintAST(v, 0).trim();
+      return `${pad}  ${colors.blue}${k}${colors.reset}:${valStr}`;
+    });
+    return `${header}
+${body.join("\n")}
+${pad}}`;
+  }
+  return `${pad}${String(node)}`;
+}
+var metaCommands = [
+  // ─── .help ──────────────────────────────────────────────────────────────
+  {
+    name: "help",
+    aliases: ["h", "?"],
+    description: "Show commands",
+    usage: ".help [command]",
+    handler: (args) => {
+      if (args.length > 0) {
+        const cmdName = args[0].toLowerCase().replace(/^\./, "");
+        const cmd = metaCommands.find(
+          (c) => c.name === cmdName || c.aliases.includes(cmdName)
+        );
+        if (cmd) {
+          return {
+            output: [
+              `${colors.cyan}.${cmd.name}${colors.reset} \u2014 ${cmd.description}`,
+              `Usage: ${cmd.usage}`,
+              cmd.aliases.length > 0 ? `Aliases: ${cmd.aliases.map((a) => "." + a).join(", ")}` : ""
+            ].filter(Boolean).join("\n")
+          };
+        }
+        return { output: formatError(`Unknown command: ${cmdName}`) };
+      }
+      const lines = [
+        "",
+        `${colors.bold}REPL Commands${colors.reset}`,
+        "",
+        ...metaCommands.map(
+          (c) => `  ${colors.cyan}.${c.name.padEnd(12)}${colors.reset} ${c.description}`
+        ),
+        "",
+        `${colors.bold}ISL Input${colors.reset}`,
+        "",
+        `  Type ISL directly \u2014 multi-line supported (braces auto-detect):`,
+        "",
+        `  ${colors.yellow}domain${colors.reset} Example {`,
+        `    ${colors.yellow}entity${colors.reset} User {`,
+        `      id: ${colors.green}UUID${colors.reset}`,
+        `      name: ${colors.green}String${colors.reset}`,
+        `    }`,
+        `  }`,
+        "",
+        `Type ${colors.cyan}.help <command>${colors.reset} for details.`,
+        ""
+      ];
+      return { output: lines.join("\n") };
+    }
+  },
+  // ─── .parse ─────────────────────────────────────────────────────────────
+  {
+    name: "parse",
+    aliases: ["p", "ast"],
+    description: "Parse ISL and show AST",
+    usage: ".parse <isl>",
+    handler: (args, session) => {
+      const input = args.join(" ").trim();
+      if (!input) {
+        return { output: 'Usage: .parse <isl code>\nExample: .parse domain Foo { version: "1.0" }' };
+      }
+      try {
+        const { parse } = __require("@isl-lang/parser");
+        const result = parse(input, "<repl>");
+        if (!result.success || result.errors.length > 0) {
+          const errLines = result.errors.map((e) => {
+            const loc = e.location;
+            if (loc) {
+              return formatParseError(input, e.message, loc.line, loc.column);
+            }
+            return formatError(e.message);
+          });
+          return { output: errLines.join("\n") };
+        }
+        if (result.domain) {
+          session.setDomainAST(result.domain);
+          return {
+            output: formatSuccess("Parsed successfully") + "\n" + prettyPrintAST(result.domain)
+          };
+        }
+        return { output: formatWarning("Parse returned no AST") };
+      } catch {
+        return {
+          output: formatWarning(
+            "Real parser not available \u2014 install @isl-lang/parser.\nFalling back to simple parse."
+          )
+        };
+      }
+    }
+  },
+  // ─── .eval ──────────────────────────────────────────────────────────────
+  {
+    name: "eval",
+    aliases: ["e"],
+    description: "Evaluate expression against context",
+    usage: ".eval <expression>",
+    handler: (args, session) => {
+      const expr = args.join(" ").trim();
+      if (!expr) {
+        return {
+          output: [
+            "Usage: .eval <expression>",
+            "",
+            "Examples:",
+            '  .eval user.email == "test@x.com"',
+            "  .eval user.age > 30",
+            "  .eval old(user.age)",
+            "",
+            'Set context first: .context { "user": { "email": "test@x.com" } }'
+          ].join("\n")
+        };
+      }
+      const result = evaluateExpression(expr, session);
+      if (result.error) {
+        return { output: formatError(result.error) };
+      }
+      session.setLastResult(result.value);
+      return {
+        output: `${colors.cyan}\u2192${colors.reset} ${formatValue(result.value)}`
+      };
+    }
+  },
+  // ─── .check ─────────────────────────────────────────────────────────────
+  {
+    name: "check",
+    aliases: ["c"],
+    description: "Type check the current session",
+    usage: ".check [intent]",
+    handler: (args, session) => {
+      if (args.length > 0) {
+        const intentName = args[0];
+        const intent = session.getIntent(intentName);
+        if (!intent) {
+          const available = session.getIntentNames().join(", ") || "(none)";
+          return {
+            output: formatError(`Unknown intent: ${intentName}
+Available: ${available}`)
+          };
+        }
+        const lines2 = [formatSuccess("Type check passed"), ""];
+        for (const pre of intent.preconditions) {
+          lines2.push(`  ${colors.green}\u2713${colors.reset} pre: ${highlightExpression(pre.expression)}`);
+        }
+        for (const post of intent.postconditions) {
+          lines2.push(`  ${colors.green}\u2713${colors.reset} post: ${highlightExpression(post.expression)}`);
+        }
+        return { output: lines2.join("\n") };
+      }
+      const intents = session.getAllIntents();
+      if (intents.length === 0) {
+        return {
+          output: formatWarning("No intents defined. Write ISL or use .load <file>")
+        };
+      }
+      const lines = [formatSuccess(`Type check passed \u2014 ${intents.length} intent(s)`), ""];
+      for (const intent of intents) {
+        lines.push(`${colors.bold}${intent.name}${colors.reset}`);
+        for (const pre of intent.preconditions) {
+          lines.push(`  ${colors.green}\u2713${colors.reset} pre: ${highlightExpression(pre.expression)}`);
+        }
+        for (const post of intent.postconditions) {
+          lines.push(`  ${colors.green}\u2713${colors.reset} post: ${highlightExpression(post.expression)}`);
+        }
+        lines.push("");
+      }
+      return { output: lines.join("\n") };
+    }
+  },
+  // ─── .gen ───────────────────────────────────────────────────────────────
+  {
+    name: "gen",
+    aliases: ["generate", "g"],
+    description: "Generate TypeScript from intent",
+    usage: ".gen [intent]",
+    handler: (args, session) => {
+      const intents = args.length > 0 ? [session.getIntent(args[0])].filter(Boolean) : session.getAllIntents();
+      if (intents.length === 0) {
+        return {
+          output: args.length > 0 ? formatError(`Unknown intent: ${args[0]}
+Available: ${session.getIntentNames().join(", ") || "(none)"}`) : formatWarning("No intents defined. Write ISL or use .load <file>")
+        };
+      }
+      const lines = [`${colors.gray}// Generated TypeScript${colors.reset}`, ""];
+      for (const intent of intents) {
+        lines.push(`interface ${intent.name}Contract {`);
+        if (intent.preconditions.length > 0) {
+          lines.push("  /** Preconditions */");
+          for (const pre of intent.preconditions) {
+            lines.push(`  checkPre(): boolean; // ${pre.expression}`);
+          }
+        }
+        if (intent.postconditions.length > 0) {
+          lines.push("  /** Postconditions */");
+          for (const post of intent.postconditions) {
+            lines.push(`  checkPost(): boolean; // ${post.expression}`);
+          }
+        }
+        if (intent.invariants.length > 0) {
+          lines.push("  /** Invariants */");
+          for (const inv of intent.invariants) {
+            lines.push(`  checkInvariant(): boolean; // ${inv.expression}`);
+          }
+        }
+        lines.push("}");
+        lines.push("");
+      }
+      return { output: lines.join("\n") };
+    }
+  },
+  // ─── .load ──────────────────────────────────────────────────────────────
+  {
+    name: "load",
+    aliases: ["l"],
+    description: "Load an .isl file",
+    usage: ".load <file.isl>",
+    handler: (args, session) => {
+      if (args.length === 0) {
+        return { output: "Usage: .load <file.isl>" };
+      }
+      const filePath = args[0];
+      const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);
+      if (!fs2.existsSync(resolvedPath)) {
+        return { output: formatError(`File not found: ${resolvedPath}`) };
+      }
+      try {
+        const content = fs2.readFileSync(resolvedPath, "utf-8");
+        try {
+          const { parse } = __require("@isl-lang/parser");
+          const result = parse(content, resolvedPath);
+          if (!result.success || result.errors.length > 0) {
+            const errLines = result.errors.map((e) => {
+              const loc = e.location;
+              if (loc) {
+                return formatParseError(content, e.message, loc.line, loc.column);
+              }
+              return formatError(e.message);
+            });
+            return { output: errLines.join("\n") };
+          }
+          if (result.domain) {
+            session.setDomainAST(result.domain);
+            const domain = result.domain;
+            const name = domain.name?.name ?? "Unknown";
+            const entityCount = domain.entities?.length ?? 0;
+            const behaviorCount = domain.behaviors?.length ?? 0;
+            return {
+              output: formatSuccess(
+                `Loaded: ${name} (${entityCount} entities, ${behaviorCount} behaviors) from ${path.basename(filePath)}`
+              )
+            };
+          }
+        } catch {
+        }
+        const intentRegex = /(?:intent|behavior)\s+(\w+)\s*\{[^}]*(?:\{[^}]*\}[^}]*)*\}/g;
+        let match;
+        let count = 0;
+        while ((match = intentRegex.exec(content)) !== null) {
+          const intent = session.parseIntent(match[0]);
+          if (intent) {
+            session.defineIntent(intent);
+            count++;
+          }
+        }
+        if (count === 0) {
+          return { output: formatWarning("No intents/behaviors found in file") };
+        }
+        return {
+          output: formatSuccess(`Loaded ${count} intent(s) from ${path.basename(filePath)}`)
+        };
+      } catch (error) {
+        return {
+          output: formatError(
+            `Failed to load: ${error instanceof Error ? error.message : String(error)}`
+          )
+        };
+      }
+    }
+  },
+  // ─── .context ───────────────────────────────────────────────────────────
+  {
+    name: "context",
+    aliases: ["ctx"],
+    description: "Set evaluation context (JSON)",
+    usage: ".context <json>  |  .context --pre <json>",
+    handler: (args, session) => {
+      const input = args.join(" ").trim();
+      if (!input) {
+        const ctx = session.getEvalContext();
+        const pre = session.getPreContext();
+        if (Object.keys(ctx).length === 0 && !pre) {
+          return {
+            output: [
+              "No context set.",
+              "",
+              "Usage:",
+              '  .context { "user": { "email": "test@x.com", "age": 25 } }',
+              '  .context --pre { "user": { "age": 20 } }'
+            ].join("\n")
+          };
+        }
+        const lines = [];
+        if (Object.keys(ctx).length > 0) {
+          lines.push(`${colors.bold}Context:${colors.reset}`);
+          lines.push(formatValue(ctx));
+        }
+        if (pre) {
+          lines.push(`${colors.bold}Pre-state:${colors.reset}`);
+          lines.push(formatValue(pre));
+        }
+        return { output: lines.join("\n") };
+      }
+      if (input.startsWith("--pre ")) {
+        const json = input.slice(6).trim();
+        const result2 = session.setPreContext(json);
+        if (!result2.success) {
+          return { output: formatError(`Invalid JSON: ${result2.error}`) };
+        }
+        return { output: formatSuccess("Pre-state context set") };
+      }
+      const result = session.setEvalContext(input);
+      if (!result.success) {
+        return { output: formatError(`Invalid JSON: ${result.error}`) };
+      }
+      return {
+        output: formatSuccess(
+          `Context set (${result.count} variable${result.count !== 1 ? "s" : ""})`
+        )
+      };
+    }
+  },
+  // ─── .clear ─────────────────────────────────────────────────────────────
+  {
+    name: "clear",
+    aliases: ["cls", "reset"],
+    description: "Reset session state",
+    usage: ".clear",
+    handler: (_args, session) => {
+      session.clear();
+      return { output: formatSuccess("Session cleared") };
+    }
+  },
+  // ─── .history ───────────────────────────────────────────────────────────
+  {
+    name: "history",
+    aliases: ["hist"],
+    description: "Show command history",
+    usage: ".history [n]",
+    handler: (args, session) => {
+      const count = args.length > 0 ? parseInt(args[0], 10) : 10;
+      const history = session.getHistory(count);
+      if (history.length === 0) {
+        return { output: "No history." };
+      }
+      const lines = [
+        `${colors.bold}History${colors.reset} (last ${history.length} entries)`,
+        "",
+        ...history.map((entry, i) => {
+          const num = String(i + 1).padStart(3);
+          const preview = entry.split("\n")[0];
+          const more = entry.includes("\n") ? ` ${colors.gray}...${colors.reset}` : "";
+          return `  ${colors.gray}${num}${colors.reset} ${preview}${more}`;
+        })
+      ];
+      return { output: lines.join("\n") };
+    }
+  },
+  // ─── .list ──────────────────────────────────────────────────────────────
+  {
+    name: "list",
+    aliases: ["ls"],
+    description: "List defined intents",
+    usage: ".list",
+    handler: (_args, session) => {
+      const intents = session.getAllIntents();
+      if (intents.length === 0) {
+        return { output: "No intents defined." };
+      }
+      const lines = [""];
+      for (const intent of intents) {
+        const parts = [];
+        if (intent.preconditions.length > 0) parts.push(`${intent.preconditions.length} pre`);
+        if (intent.postconditions.length > 0) parts.push(`${intent.postconditions.length} post`);
+        if (intent.invariants.length > 0) parts.push(`${intent.invariants.length} invariant`);
+        const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+        lines.push(`  ${colors.cyan}${intent.name}${colors.reset}${summary}`);
+      }
+      lines.push("");
+      return { output: lines.join("\n") };
+    }
+  },
+  // ─── .inspect ───────────────────────────────────────────────────────────
+  {
+    name: "inspect",
+    aliases: ["i", "show"],
+    description: "Show full details of an intent",
+    usage: ".inspect [intent]",
+    handler: (args, session) => {
+      if (args.length === 0) {
+        const summary = session.getSummary();
+        const ctx = session.getEvalContext();
+        const lines = [
+          "",
+          `${colors.bold}Session Summary${colors.reset}`,
+          "",
+          `  Intents:    ${summary.intentCount}`,
+          `  Variables:  ${summary.variableCount}`,
+          `  Context:    ${Object.keys(ctx).length} keys`,
+          `  History:    ${summary.historyCount} entries`,
+          ""
+        ];
+        return { output: lines.join("\n") };
+      }
+      const intentName = args[0];
+      const intent = session.getIntent(intentName);
+      if (!intent) {
+        const available = session.getIntentNames().join(", ") || "(none)";
+        return {
+          output: formatError(`Unknown intent: ${intentName}
+Available: ${available}`)
+        };
+      }
+      return { output: formatIntent(intent) };
+    }
+  },
+  // ─── .exit ──────────────────────────────────────────────────────────────
+  {
+    name: "exit",
+    aliases: ["quit", "q"],
+    description: "Exit the REPL",
+    usage: ".exit",
+    handler: () => {
+      return { exit: true };
+    }
+  }
+];
+var islCommands = [];
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      const cost = a[j - 1] === b[i - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function findSimilarCommand(input, _type) {
+  const names = metaCommands.flatMap((c) => [c.name, ...c.aliases]);
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  for (const name of names) {
+    const distance = levenshteinDistance(input.toLowerCase(), name.toLowerCase());
+    if (distance < bestDistance && distance <= 2) {
+      bestDistance = distance;
+      bestMatch = name;
+    }
+  }
+  return bestMatch;
+}
+
+// src/completions.ts
+var KEYWORDS = [
+  // Structure keywords
+  { text: "domain", type: "keyword", description: "Define a domain" },
+  { text: "entity", type: "keyword", description: "Define an entity" },
+  { text: "behavior", type: "keyword", description: "Define a behavior" },
+  { text: "intent", type: "keyword", description: "Define an intent" },
+  { text: "input", type: "keyword", description: "Input block" },
+  { text: "output", type: "keyword", description: "Output block" },
+  { text: "pre", type: "keyword", description: "Precondition" },
+  { text: "post", type: "keyword", description: "Postcondition" },
+  { text: "invariant", type: "keyword", description: "Invariant" },
+  { text: "scenario", type: "keyword", description: "Scenario block" },
+  { text: "version", type: "keyword", description: "Version declaration" },
+  // Types
+  { text: "String", type: "keyword", description: "String type" },
+  { text: "Number", type: "keyword", description: "Number type" },
+  { text: "Int", type: "keyword", description: "Integer type" },
+  { text: "Decimal", type: "keyword", description: "Decimal type" },
+  { text: "Boolean", type: "keyword", description: "Boolean type" },
+  { text: "UUID", type: "keyword", description: "UUID type" },
+  { text: "Timestamp", type: "keyword", description: "Timestamp type" },
+  { text: "Duration", type: "keyword", description: "Duration type" },
+  { text: "List", type: "keyword", description: "List<T> type" },
+  { text: "Map", type: "keyword", description: "Map<K,V> type" },
+  { text: "Optional", type: "keyword", description: "Optional<T> type" },
+  // Literals and operators
+  { text: "true", type: "keyword", description: "Boolean true" },
+  { text: "false", type: "keyword", description: "Boolean false" },
+  { text: "null", type: "keyword", description: "Null value" },
+  { text: "and", type: "keyword", description: "Logical AND" },
+  { text: "or", type: "keyword", description: "Logical OR" },
+  { text: "not", type: "keyword", description: "Logical NOT" },
+  { text: "implies", type: "keyword", description: "Logical implication" },
+  { text: "forall", type: "keyword", description: "Universal quantifier" },
+  { text: "exists", type: "keyword", description: "Existential quantifier" },
+  { text: "in", type: "keyword", description: "Membership test" },
+  { text: "old", type: "keyword", description: "Pre-state value (old(x))" }
+];
+var META_COMMANDS = metaCommands.map((cmd) => ({
+  text: `.${cmd.name}`,
+  type: "command",
+  description: cmd.description
+}));
+var ISL_COMMANDS = [];
+var COMMANDS = [...META_COMMANDS];
+var GEN_TARGETS = [
+  { text: "typescript", type: "keyword", description: "Generate TypeScript contract" },
+  { text: "rust", type: "keyword", description: "Generate Rust contract" },
+  { text: "go", type: "keyword", description: "Generate Go contract" },
+  { text: "openapi", type: "keyword", description: "Generate OpenAPI schema" }
+];
+var CompletionProvider = class {
+  constructor(session) {
+    this.session = session;
+  }
+  /**
+   * Update the session reference
+   */
+  setSession(session) {
+    this.session = session;
+  }
+  /**
+   * Get completions for a line
+   */
+  complete(line) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith(".")) {
+      return this.completeMetaCommand(trimmed);
+    }
+    if (trimmed.startsWith(":")) {
+      return this.completeMetaCommand("." + trimmed.slice(1));
+    }
+    return this.completeExpression(trimmed);
+  }
+  /**
+   * Complete meta commands
+   */
+  completeMetaCommand(line) {
+    const parts = line.slice(1).split(/\s+/);
+    const cmdPart = parts[0] || "";
+    if (parts.length === 1) {
+      const matches = META_COMMANDS.filter(
+        (c) => c.text.toLowerCase().startsWith(`.${cmdPart.toLowerCase()}`)
+      );
+      return [matches.length > 0 ? matches : META_COMMANDS, "." + cmdPart];
+    }
+    return [[], line];
+  }
+  /**
+   * Complete ISL commands
+   */
+  completeISLCommand(line) {
+    const parts = line.slice(1).split(/\s+/);
+    const cmdPart = parts[0] || "";
+    const args = parts.slice(1);
+    if (parts.length === 1) {
+      const matches = ISL_COMMANDS.filter(
+        (c) => c.text.toLowerCase().startsWith(`:${cmdPart.toLowerCase()}`)
+      );
+      return [matches.length > 0 ? matches : ISL_COMMANDS, ":" + cmdPart];
+    }
+    const cmd = cmdPart.toLowerCase();
+    switch (cmd) {
+      case "gen":
+      case "generate":
+      case "g":
+        return this.completeGenCommand(args);
+      case "check":
+      case "c":
+      case "inspect":
+      case "i":
+      case "show":
+        return this.completeIntentName(args[0] || "");
+      case "load":
+      case "l":
+      case "export":
+      case "save":
+        return this.completeFilePath(args[0] || "");
+      default:
+        return [[], line];
+    }
+  }
+  /**
+   * Complete :gen command arguments
+   */
+  completeGenCommand(args) {
+    if (args.length <= 1) {
+      const partial = args[0] || "";
+      const matches = GEN_TARGETS.filter(
+        (t) => t.text.toLowerCase().startsWith(partial.toLowerCase())
+      );
+      return [matches.length > 0 ? matches : GEN_TARGETS, partial];
+    }
+    return this.completeIntentName(args[1] || "");
+  }
+  /**
+   * Complete intent names
+   */
+  completeIntentName(partial) {
+    const intents = this.session.getAllIntents();
+    const items = intents.map((intent) => ({
+      text: intent.name,
+      type: "intent",
+      description: `${intent.preconditions.length} pre, ${intent.postconditions.length} post`
+    }));
+    const matches = items.filter(
+      (i) => i.text.toLowerCase().startsWith(partial.toLowerCase())
+    );
+    return [matches.length > 0 ? matches : items, partial];
+  }
+  /**
+   * Complete file paths
+   */
+  completeFilePath(partial) {
+    try {
+      const dir = path.dirname(partial) || ".";
+      const base = path.basename(partial);
+      const resolvedDir = path.resolve(this.session.getConfig().cwd || process.cwd(), dir);
+      if (!fs2.existsSync(resolvedDir)) {
+        return [[], partial];
+      }
+      const entries = fs2.readdirSync(resolvedDir, { withFileTypes: true });
+      const items = entries.filter((e) => {
+        const name = e.name.toLowerCase();
+        return name.startsWith(base.toLowerCase()) && (e.isDirectory() || name.endsWith(".isl"));
+      }).map((e) => ({
+        text: path.join(dir, e.name + (e.isDirectory() ? "/" : "")),
+        type: "file",
+        description: e.isDirectory() ? "Directory" : "ISL file"
+      }));
+      return [items, partial];
+    } catch {
+      return [[], partial];
+    }
+  }
+  /**
+   * Complete expressions
+   */
+  completeExpression(line) {
+    const items = [...KEYWORDS];
+    for (const intent of this.session.getAllIntents()) {
+      items.push({
+        text: intent.name,
+        type: "intent",
+        description: "Defined intent"
+      });
+    }
+    for (const [name] of this.session.getAllVariables()) {
+      items.push({
+        text: name,
+        type: "variable",
+        description: "Variable"
+      });
+    }
+    items.push({
+      text: "_",
+      type: "variable",
+      description: "Last result"
+    });
+    const match = line.match(/[\w.]+$/);
+    const partial = match ? match[0] : "";
+    const matches = items.filter(
+      (i) => i.text.toLowerCase().startsWith(partial.toLowerCase())
+    );
+    return [matches.length > 0 ? matches : items, partial];
+  }
+  /**
+   * Get all available completions (for help)
+   */
+  getAllCompletions() {
+    return {
+      metaCommands: META_COMMANDS,
+      islCommands: ISL_COMMANDS,
+      keywords: KEYWORDS,
+      intents: this.session.getAllIntents().map((i) => ({
+        text: i.name,
+        type: "intent",
+        description: `${i.preconditions.length} pre, ${i.postconditions.length} post`
+      }))
+    };
+  }
+};
+function createCompleter(provider) {
+  return (line) => {
+    const [items, partial] = provider.complete(line);
+    const completions = items.map((i) => i.text);
+    return [completions, partial];
+  };
+}
+
+// src/repl.ts
+var VERSION = "0.1.0";
+var PROMPT = `${colors.cyan}isl>${colors.reset} `;
+var CONTINUATION_PROMPT = `${colors.cyan}...>${colors.reset} `;
+var ISLREPL = class {
+  session;
+  history;
+  completionProvider;
+  rl = null;
+  buffer = [];
+  braceCount = 0;
+  options;
+  running = false;
+  constructor(options = {}) {
+    this.options = {
+      colors: options.colors !== false,
+      verbose: options.verbose ?? false,
+      historyFile: options.historyFile,
+      load: options.load,
+      context: options.context,
+      parseOnly: options.parseOnly ?? false
+    };
+    this.session = new Session({ colors: this.options.colors });
+    this.history = new History({
+      historyFile: this.options.historyFile
+    });
+    this.completionProvider = new CompletionProvider(this.session);
+  }
+  /**
+   * Start the REPL
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.applyStartupOptions();
+    if (this.options.parseOnly || !process.stdin.isTTY) {
+      this.runPipeMode();
+      return;
+    }
+    this.history.load();
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: PROMPT,
+      completer: createCompleter(this.completionProvider),
+      terminal: true
+    });
+    this.printBanner();
+    this.rl.prompt();
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+      if (this.rl && this.running) {
+        this.rl.setPrompt(this.braceCount > 0 ? CONTINUATION_PROMPT : PROMPT);
+        this.rl.prompt();
+      }
+    });
+    this.rl.on("close", () => {
+      this.exit();
+    });
+    this.rl.on("SIGINT", () => {
+      if (this.buffer.length > 0) {
+        this.buffer = [];
+        this.braceCount = 0;
+        process.stdout.write("\n" + formatWarning("Input cancelled") + "\n");
+        this.rl.setPrompt(PROMPT);
+        this.rl.prompt();
+      } else {
+        process.stdout.write("\n" + formatWarning("Use .exit to quit") + "\n");
+        this.rl.prompt();
+      }
+    });
+  }
+  /**
+   * Apply startup options (--load, --context)
+   */
+  applyStartupOptions() {
+    if (this.options.context) {
+      const result = this.session.setEvalContext(this.options.context);
+      if (result.success) {
+        process.stdout.write(
+          formatSuccess(`Context set (${result.count} variable${result.count !== 1 ? "s" : ""})`) + "\n"
+        );
+      } else {
+        process.stdout.write(formatError(`Invalid context JSON: ${result.error}`) + "\n");
+      }
+    }
+    if (this.options.load) {
+      const loadCmd = metaCommands.find((c) => c.name === "load");
+      if (loadCmd) {
+        const result = loadCmd.handler([this.options.load], this.session, this);
+        if (result.output) {
+          process.stdout.write(result.output + "\n");
+        }
+      }
+    }
+  }
+  /**
+   * Run in pipe mode (read all stdin, parse, and output)
+   */
+  runPipeMode() {
+    let input = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    process.stdin.on("end", () => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        process.exit(0);
+        return;
+      }
+      if (this.options.parseOnly) {
+        const parseCmd = metaCommands.find((c) => c.name === "parse");
+        if (parseCmd) {
+          const result = parseCmd.handler(trimmed.split(" "), this.session, this);
+          if (result.output) {
+            process.stdout.write(result.output + "\n");
+          }
+        }
+      } else {
+        const lines = trimmed.split("\n");
+        for (const line of lines) {
+          this.handleLine(line);
+        }
+      }
+      process.exit(0);
+    });
+  }
+  /**
+   * Print the welcome banner
+   */
+  printBanner() {
+    const banner = `
+${colors.cyan}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                               \u2551
+\u2551   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557         \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557          \u2551
+\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551         \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551          \u2551
+\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551         \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551          \u2551
+\u2551   \u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551         \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2551          \u2551
+\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557    \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557     \u2551
+\u2551   \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D    \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D     \u2551
+\u2551                                                               \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D${colors.reset}
+
+${colors.bold}ISL v${VERSION}${colors.reset} \u2014 Intent Specification Language
+Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${colors.reset} to quit
+`;
+    process.stdout.write(banner);
+  }
+  /**
+   * Handle a line of input
+   */
+  handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed && this.buffer.length === 0) {
+      return;
+    }
+    if (trimmed.startsWith(".") && this.buffer.length === 0) {
+      this.handleDotCommand(trimmed);
+      return;
+    }
+    if (trimmed.startsWith(":") && this.buffer.length === 0) {
+      this.handleDotCommand("." + trimmed.slice(1));
+      return;
+    }
+    this.braceCount += (line.match(/\{/g) || []).length;
+    this.braceCount -= (line.match(/\}/g) || []).length;
+    this.buffer.push(line);
+    if (this.braceCount <= 0) {
+      const code = this.buffer.join("\n");
+      this.buffer = [];
+      this.braceCount = 0;
+      this.history.add(code);
+      this.session.addToHistory(code);
+      this.evaluate(code);
+    }
+  }
+  /**
+   * Handle a dot command (. prefix)
+   */
+  handleDotCommand(input) {
+    const parts = input.slice(1).split(/\s+/);
+    const cmdName = parts[0]?.toLowerCase() || "";
+    const args = parts.slice(1);
+    const rawArgs = input.slice(1 + (cmdName.length || 0)).trim();
+    const command = metaCommands.find(
+      (c) => c.name === cmdName || c.aliases.includes(cmdName)
+    );
+    if (command) {
+      this.history.add(input);
+      const needsRawArgs = ["context", "ctx", "eval", "e", "parse", "p", "ast", "load", "l"];
+      const effectiveArgs = needsRawArgs.includes(cmdName) && rawArgs ? [rawArgs] : args;
+      const result = command.handler(effectiveArgs, this.session, this);
+      if (result.output) {
+        process.stdout.write(result.output + "\n");
+      }
+      if (result.exit) {
+        this.exit();
+      }
+    } else {
+      const suggestion = findSimilarCommand(cmdName);
+      if (suggestion) {
+        process.stdout.write(formatError(`Unknown command: .${cmdName}`) + "\n");
+        process.stdout.write(formatWarning(`Did you mean: .${suggestion}?`) + "\n");
+      } else {
+        process.stdout.write(formatError(`Unknown command: .${cmdName}`) + "\n");
+        process.stdout.write(`Type ${colors.cyan}.help${colors.reset} for available commands
+`);
+      }
+    }
+  }
+  /**
+   * Evaluate ISL code (multi-line input or bare expressions)
+   */
+  evaluate(code) {
+    try {
+      const trimmed = code.trim();
+      try {
+        const { parse } = __require("@isl-lang/parser");
+        let parseInput = trimmed;
+        const needsWrapper = !trimmed.startsWith("domain ");
+        if (needsWrapper) {
+          parseInput = `domain _REPL { version: "0.0.1"
+${trimmed}
+}`;
+        }
+        const result = parse(parseInput, "<repl>");
+        if (result.errors.length > 0) {
+          for (const err of result.errors) {
+            const loc = err.location;
+            if (loc) {
+              const adjustedLine = needsWrapper ? Math.max(1, loc.line - 1) : loc.line;
+              const lines = trimmed.split("\n");
+              const errorLine = lines[adjustedLine - 1] || "";
+              process.stdout.write(
+                `${colors.red}\u2717 Error at line ${adjustedLine}, col ${loc.column}:${colors.reset}
+`
+              );
+              process.stdout.write(`  ${errorLine}
+`);
+              process.stdout.write(`  ${" ".repeat(Math.max(0, loc.column - 1))}${colors.red}^^^^^${colors.reset}
+`);
+              const typeMatch = err.message.match(/Unknown type '(\w+)'/i) || err.message.match(/unexpected.*'(\w+)'/i);
+              if (typeMatch) {
+                const suggestion = suggestCorrection(typeMatch[1]);
+                if (suggestion) {
+                  process.stdout.write(
+                    `  ${colors.yellow}Did you mean '${suggestion}'?${colors.reset}
+`
+                  );
+                }
+              } else {
+                process.stdout.write(`  ${err.message}
+`);
+              }
+            } else {
+              process.stdout.write(formatError(err.message) + "\n");
+            }
+          }
+          return;
+        }
+        if (result.domain) {
+          this.session.setDomainAST(result.domain);
+          const domain = result.domain;
+          if (needsWrapper) {
+            const entityCount = domain.entities?.length ?? 0;
+            const behaviorCount = domain.behaviors?.length ?? 0;
+            const parts = [];
+            if (entityCount > 0) parts.push(`${entityCount} entit${entityCount === 1 ? "y" : "ies"}`);
+            if (behaviorCount > 0) parts.push(`${behaviorCount} behavior${behaviorCount === 1 ? "" : "s"}`);
+            if (parts.length > 0) {
+              process.stdout.write(
+                formatSuccess(`Parsed: ${parts.join(", ")}`) + "\n"
+              );
+            } else {
+              process.stdout.write(formatSuccess("Parsed successfully") + "\n");
+            }
+          } else {
+            const name = domain.name?.name ?? "Unknown";
+            const entityCount = domain.entities?.length ?? 0;
+            const behaviorCount = domain.behaviors?.length ?? 0;
+            process.stdout.write(
+              formatSuccess(
+                `Parsed: domain ${name} (${entityCount} entit${entityCount === 1 ? "y" : "ies"}, ${behaviorCount} behavior${behaviorCount === 1 ? "" : "s"})`
+              ) + "\n"
+            );
+          }
+          return;
+        }
+      } catch {
+      }
+      if (trimmed.startsWith("intent ") || trimmed.startsWith("behavior ")) {
+        this.evaluateIntent(trimmed);
+        return;
+      }
+      if (trimmed.startsWith("domain ")) {
+        process.stdout.write(formatSuccess("Parsed domain block") + "\n");
+        return;
+      }
+      process.stdout.write(
+        formatWarning(`Cannot evaluate: ${trimmed.split("\n")[0]}...`) + "\n"
+      );
+      process.stdout.write(
+        `Use ${colors.cyan}.help${colors.reset} for available commands
+`
+      );
+    } catch (error) {
+      this.printError(error);
+    }
+  }
+  /**
+   * Evaluate an intent definition
+   */
+  evaluateIntent(code) {
+    const intent = this.session.parseIntent(code);
+    if (intent) {
+      this.session.defineIntent(intent);
+      const preCount = intent.preconditions.length;
+      const postCount = intent.postconditions.length;
+      const invCount = intent.invariants.length;
+      const parts = [];
+      if (preCount > 0) parts.push(`${preCount} pre`);
+      if (postCount > 0) parts.push(`${postCount} post`);
+      if (invCount > 0) parts.push(`${invCount} invariant`);
+      const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+      process.stdout.write(
+        formatSuccess(`Intent '${intent.name}' defined${summary}`) + "\n"
+      );
+    } else {
+      const behaviorMatch = code.match(/^behavior\s+(\w+)\s*\{([\s\S]*)\}$/);
+      if (behaviorMatch) {
+        const name = behaviorMatch[1];
+        const body = behaviorMatch[2];
+        const newIntent = {
+          name,
+          preconditions: [],
+          postconditions: [],
+          invariants: [],
+          scenarios: [],
+          rawSource: code
+        };
+        const preSection = body.match(/pre(?:conditions)?\s*\{([^}]*)\}/s);
+        if (preSection) {
+          for (const line of preSection[1].trim().split("\n")) {
+            const expr = line.trim().replace(/^-\s*/, "").trim();
+            if (expr) newIntent.preconditions.push({ expression: expr });
+          }
+        }
+        const postSection = body.match(/post(?:conditions)?\s*\{([^}]*)\}/s);
+        if (postSection) {
+          for (const line of postSection[1].trim().split("\n")) {
+            const expr = line.trim().replace(/^-\s*/, "").trim();
+            if (expr) newIntent.postconditions.push({ expression: expr });
+          }
+        }
+        this.session.defineIntent(newIntent);
+        const parts = [];
+        if (newIntent.preconditions.length > 0) parts.push(`${newIntent.preconditions.length} pre`);
+        if (newIntent.postconditions.length > 0) parts.push(`${newIntent.postconditions.length} post`);
+        const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+        process.stdout.write(
+          formatSuccess(`Intent '${name}' defined${summary}`) + "\n"
+        );
+      } else {
+        process.stdout.write(formatError("Failed to parse intent definition") + "\n");
+      }
+    }
+  }
+  /**
+   * Print an error
+   */
+  printError(error) {
+    if (error instanceof Error) {
+      process.stdout.write(formatError(error.message) + "\n");
+      if (this.options.verbose && error.stack) {
+        process.stdout.write(colors.gray + error.stack + colors.reset + "\n");
+      }
+    } else {
+      process.stdout.write(formatError(String(error)) + "\n");
+    }
+  }
+  /**
+   * Exit the REPL
+   */
+  exit() {
+    this.running = false;
+    this.history.save();
+    process.stdout.write(`
+${colors.yellow}Goodbye!${colors.reset}
+`);
+    if (this.rl) {
+      this.rl.close();
+    }
+    process.exit(0);
+  }
+  /**
+   * Get the session
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Get history
+   */
+  getHistory() {
+    return this.history;
+  }
+  /**
+   * Execute a single command and return result (for testing)
+   */
+  async executeOnce(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith(".") || trimmed.startsWith(":")) {
+      const normalized = trimmed.startsWith(":") ? "." + trimmed.slice(1) : trimmed;
+      const parts = normalized.slice(1).split(/\s+/);
+      const cmdName = parts[0]?.toLowerCase() || "";
+      const rawArgs = normalized.slice(1 + (cmdName.length || 0)).trim();
+      const command = metaCommands.find(
+        (c) => c.name === cmdName || c.aliases.includes(cmdName)
+      );
+      if (command) {
+        const needsRawArgs = ["context", "ctx", "eval", "e", "parse", "p", "ast", "load", "l"];
+        const effectiveArgs = needsRawArgs.includes(cmdName) && rawArgs ? [rawArgs] : parts.slice(1);
+        const result = command.handler(effectiveArgs, this.session, this);
+        return { success: true, output: result.output };
+      }
+      return { success: false, error: `Unknown command: ${cmdName}` };
+    }
+    if (trimmed.startsWith("intent ") || trimmed.startsWith("behavior ")) {
+      const intent = this.session.parseIntent(trimmed);
+      if (intent) {
+        this.session.defineIntent(intent);
+        return { success: true, output: `Intent '${intent.name}' defined` };
+      }
+      return { success: false, error: "Failed to parse intent" };
+    }
+    return { success: false, error: "Unknown input" };
+  }
+};
+var KNOWN_TYPES = [
+  "String",
+  "Int",
+  "Decimal",
+  "Boolean",
+  "UUID",
+  "Timestamp",
+  "Duration",
+  "List",
+  "Map",
+  "Optional",
+  "Number"
+];
+function suggestCorrection(typo) {
+  const lower = typo.toLowerCase();
+  for (const t of KNOWN_TYPES) {
+    if (t.toLowerCase() === lower) return t;
+    if (t.toLowerCase().startsWith(lower.slice(0, 3)) && Math.abs(t.length - typo.length) <= 2) {
+      return t;
+    }
+  }
+  return null;
+}
+function startREPL(options) {
+  const repl = new ISLREPL(options);
+  repl.start();
+  return repl;
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const options = {
+    help: false,
+    colors: true,
+    verbose: false,
+    parseOnly: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        options.help = true;
+        break;
+      case "--no-color":
+        options.colors = false;
+        break;
+      case "--verbose":
+      case "-v":
+        options.verbose = true;
+        break;
+      case "--load":
+        options.load = argv[++i];
+        break;
+      case "--context":
+        options.context = argv[++i];
+        break;
+      case "--parse":
+        options.parseOnly = true;
+        break;
+      default:
+        if (arg.startsWith("--load=")) {
+          options.load = arg.slice(7);
+        } else if (arg.startsWith("--context=")) {
+          options.context = arg.slice(10);
+        }
+        break;
+    }
+  }
+  return options;
+}
+function printHelp() {
+  process.stdout.write(`
+ISL REPL - Intent Specification Language Interactive Shell
+
+Usage: isl-repl [options]
+
+Options:
+  --load <file>       Load an ISL file on start
+  --context <json>    Set initial evaluation context
+  --parse             Parse mode (non-interactive, for piped input)
+  --no-color          Disable colored output
+  -v, --verbose       Enable verbose output
+  -h, --help          Show this help message
+
+Inside the REPL:
+  .help               Show all commands
+  .parse <isl>        Parse ISL and show AST
+  .eval <expr>        Evaluate expression against context
+  .check [intent]     Type check intents
+  .gen [intent]       Generate TypeScript from intent
+  .load <file>        Load an .isl file
+  .context <json>     Set evaluation context (mock data)
+  .clear              Reset session state
+  .list               List defined intents
+  .inspect [intent]   Show full details of an intent
+  .history            Show command history
+  .exit               Exit the REPL
+
+Multi-line Input:
+  Type ISL with braces \u2014 the REPL auto-detects multi-line:
+  isl> domain Example {
+  ...>   entity User {
+  ...>     id: UUID
+  ...>     name: String
+  ...>   }
+  ...> }
+
+Examples:
+  $ isl-repl
+  $ isl-repl --load auth.isl
+  $ isl-repl --context '{"user": {"id": 1}}'
+  $ echo 'domain X { version: "1.0" }' | isl-repl --parse
+`);
+}
+function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+  startREPL(options);
+}
+var isMainModule = typeof __require !== "undefined" ? __require.main === module : process.argv[1]?.includes("cli");
+if (isMainModule) {
+  main();
+}
+
+export { COMMANDS, CompletionProvider, History, ISLREPL, ISL_COMMANDS, KEYWORDS, META_COMMANDS, MemoryHistory, Session, colors, createCompleter, createSession, drawBox, findSimilarCommand, formatCondition, formatError, formatInfo, formatIntent, formatParseError, formatSuccess, formatTable, formatTypeError, formatValue, formatWarning, highlightExpression, highlightISL, islCommands, main, metaCommands, startREPL, stripColors, wrapText };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map