@isl-lang/repl 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1812 @@
+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;
+  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)}`
+      };
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // State Management
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Clear all session state
+   */
+  clear() {
+    this.intents.clear();
+    this.variables.clear();
+    this.lastResult = void 0;
+    this.loadedFiles.clear();
+  }
+  /**
+   * 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
+var metaCommands = [
+  {
+    name: "help",
+    aliases: ["h", "?"],
+    description: "Show help for commands",
+    usage: ".help [command]",
+    handler: (args, session) => {
+      if (args.length > 0) {
+        const cmdName = args[0].toLowerCase();
+        const metaCmd = metaCommands.find((c) => c.name === cmdName || c.aliases.includes(cmdName));
+        if (metaCmd) {
+          return {
+            output: [
+              `${colors.cyan}.${metaCmd.name}${colors.reset} - ${metaCmd.description}`,
+              `Usage: ${metaCmd.usage}`,
+              metaCmd.aliases.length > 0 ? `Aliases: ${metaCmd.aliases.map((a) => "." + a).join(", ")}` : ""
+            ].filter(Boolean).join("\n")
+          };
+        }
+        const islCmd = islCommands.find((c) => c.name === cmdName || c.aliases.includes(cmdName));
+        if (islCmd) {
+          return {
+            output: [
+              `${colors.cyan}:${islCmd.name}${colors.reset} - ${islCmd.description}`,
+              `Usage: ${islCmd.usage}`,
+              islCmd.aliases.length > 0 ? `Aliases: ${islCmd.aliases.map((a) => ":" + a).join(", ")}` : ""
+            ].filter(Boolean).join("\n")
+          };
+        }
+        return { output: formatError(`Unknown command: ${cmdName}`) };
+      }
+      const lines = [
+        "",
+        `${colors.bold}Meta Commands${colors.reset} ${colors.gray}(REPL control)${colors.reset}`,
+        "",
+        ...metaCommands.map((c) => `  ${colors.cyan}.${c.name.padEnd(10)}${colors.reset} ${c.description}`),
+        "",
+        `${colors.bold}ISL Commands${colors.reset} ${colors.gray}(specification operations)${colors.reset}`,
+        "",
+        ...islCommands.map((c) => `  ${colors.cyan}:${c.name.padEnd(10)}${colors.reset} ${c.description}`),
+        "",
+        `${colors.bold}ISL Syntax${colors.reset}`,
+        "",
+        `  ${colors.yellow}intent${colors.reset} Name {`,
+        `    ${colors.magenta}pre${colors.reset}: condition`,
+        `    ${colors.magenta}post${colors.reset}: condition`,
+        `  }`,
+        "",
+        `Type ${colors.cyan}.help <command>${colors.reset} for detailed help.`,
+        ""
+      ];
+      return { output: lines.join("\n") };
+    }
+  },
+  {
+    name: "exit",
+    aliases: ["quit", "q"],
+    description: "Exit the REPL",
+    usage: ".exit",
+    handler: () => {
+      return { exit: true };
+    }
+  },
+  {
+    name: "clear",
+    aliases: ["cls"],
+    description: "Clear session state (intents, variables)",
+    usage: ".clear",
+    handler: (args, session) => {
+      session.clear();
+      return { output: formatSuccess("Session cleared") };
+    }
+  },
+  {
+    name: "history",
+    aliases: ["hist"],
+    description: "Show command history",
+    usage: ".history [n]",
+    handler: (args, session) => {
+      const count = args.length > 0 ? parseInt(args[0]) : 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") };
+    }
+  }
+];
+var islCommands = [
+  {
+    name: "check",
+    aliases: ["c"],
+    description: "Type check an intent",
+    usage: ":check <intent>",
+    handler: (args, session) => {
+      if (args.length === 0) {
+        const intents = session.getAllIntents();
+        if (intents.length === 0) {
+          return { output: formatWarning("No intents defined. Define one with: intent Name { ... }") };
+        }
+        const lines2 = [
+          formatSuccess("Type check passed"),
+          ""
+        ];
+        for (const intent2 of intents) {
+          lines2.push(`${colors.bold}${intent2.name}${colors.reset}`);
+          for (const pre of intent2.preconditions) {
+            lines2.push(`  ${colors.green}\u2713${colors.reset} pre: ${highlightCondition(pre.expression)}`);
+          }
+          for (const post of intent2.postconditions) {
+            lines2.push(`  ${colors.green}\u2713${colors.reset} post: ${highlightCondition(post.expression)}`);
+          }
+          lines2.push("");
+        }
+        return { output: lines2.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}`)
+        };
+      }
+      const lines = [
+        formatSuccess("Type check passed"),
+        ""
+      ];
+      for (const pre of intent.preconditions) {
+        lines.push(`  pre: ${highlightCondition(pre.expression)} ${colors.green}\u2713${colors.reset}`);
+      }
+      for (const post of intent.postconditions) {
+        lines.push(`  post: ${highlightCondition(post.expression)} ${colors.green}\u2713${colors.reset}`);
+      }
+      return { output: lines.join("\n") };
+    }
+  },
+  {
+    name: "gen",
+    aliases: ["generate", "g"],
+    description: "Generate code from an intent",
+    usage: ":gen <target> <intent>",
+    handler: (args, session) => {
+      if (args.length < 2) {
+        return {
+          output: [
+            "Usage: :gen <target> <intent>",
+            "",
+            "Targets:",
+            "  typescript  Generate TypeScript contract",
+            "  rust        Generate Rust contract",
+            "  go          Generate Go contract",
+            "  openapi     Generate OpenAPI schema"
+          ].join("\n")
+        };
+      }
+      const target = args[0].toLowerCase();
+      const intentName = args[1];
+      const intent = session.getIntent(intentName);
+      if (!intent) {
+        const available = session.getIntentNames().join(", ") || "(none)";
+        return {
+          output: formatError(`Unknown intent: ${intentName}
+Available: ${available}`)
+        };
+      }
+      switch (target) {
+        case "typescript":
+        case "ts":
+          return { output: generateTypeScript(intent) };
+        case "rust":
+        case "rs":
+          return { output: generateRust(intent) };
+        case "go":
+          return { output: generateGo(intent) };
+        case "openapi":
+        case "oas":
+          return { output: generateOpenAPI(intent) };
+        default:
+          return {
+            output: formatError(`Unknown target: ${target}
+Available: typescript, rust, go, openapi`)
+          };
+      }
+    }
+  },
+  {
+    name: "load",
+    aliases: ["l"],
+    description: "Load intents from a file",
+    usage: ":load <file.isl>",
+    handler: (args, session) => {
+      if (args.length === 0) {
+        return { output: "Usage: :load <file.isl>" };
+      }
+      const filePath = args[0];
+      let result = { errors: [] };
+      session.loadFile(filePath).then((r) => {
+        result = r;
+      }).catch((e) => {
+        result.errors.push(String(e));
+      });
+      const fs4 = __require("fs");
+      const path4 = __require("path");
+      try {
+        const resolvedPath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
+        if (!fs4.existsSync(resolvedPath)) {
+          return { output: formatError(`File not found: ${resolvedPath}`) };
+        }
+        const content = fs4.readFileSync(resolvedPath, "utf-8");
+        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 found in file") };
+        }
+        return {
+          output: formatSuccess(`Loaded ${count} intent(s) from ${filePath}`)
+        };
+      } catch (error) {
+        return {
+          output: formatError(`Failed to load: ${error instanceof Error ? error.message : String(error)}`)
+        };
+      }
+    }
+  },
+  {
+    name: "list",
+    aliases: ["ls"],
+    description: "List all 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 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(", ")})` : "";
+        lines.push(`  ${colors.cyan}${intent.name}${colors.reset}${summary}`);
+      }
+      lines.push("");
+      return { output: lines.join("\n") };
+    }
+  },
+  {
+    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 files = session.getLoadedFiles();
+        const lines = [
+          "",
+          `${colors.bold}Session Summary${colors.reset}`,
+          "",
+          `  Intents:    ${summary.intentCount}`,
+          `  Variables:  ${summary.variableCount}`,
+          `  History:    ${summary.historyCount} entries`
+        ];
+        if (files.length > 0) {
+          lines.push("");
+          lines.push(`${colors.bold}Loaded Files${colors.reset}`);
+          for (const file of files) {
+            lines.push(`  ${file}`);
+          }
+        }
+        lines.push("");
+        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) };
+    }
+  },
+  {
+    name: "export",
+    aliases: ["save"],
+    description: "Export intents to a file",
+    usage: ":export <file.isl>",
+    handler: (args, session) => {
+      if (args.length === 0) {
+        return { output: "Usage: :export <file.isl>" };
+      }
+      const filePath = args[0];
+      const fs4 = __require("fs");
+      const path4 = __require("path");
+      try {
+        const resolvedPath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
+        const intents = session.getAllIntents();
+        if (intents.length === 0) {
+          return { output: formatWarning("No intents to export") };
+        }
+        const lines = [];
+        lines.push("// Exported ISL intents");
+        lines.push(`// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        lines.push("");
+        for (const intent of intents) {
+          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("");
+        }
+        fs4.writeFileSync(resolvedPath, lines.join("\n"));
+        return { output: formatSuccess(`Exported ${intents.length} intent(s) to ${filePath}`) };
+      } catch (error) {
+        return {
+          output: formatError(`Failed to export: ${error instanceof Error ? error.message : String(error)}`)
+        };
+      }
+    }
+  }
+];
+function generateTypeScript(intent) {
+  const lines = [
+    `${colors.gray}// Generated TypeScript${colors.reset}`,
+    `interface ${intent.name}Contract {`
+  ];
+  if (intent.preconditions.length > 0) {
+    for (const pre of intent.preconditions) {
+      const varName = extractVariableName(pre.expression);
+      const type = inferType(pre.expression);
+      lines.push(`  pre: (${varName}: ${type}) => boolean;`);
+    }
+  }
+  if (intent.postconditions.length > 0) {
+    for (const post of intent.postconditions) {
+      const varName = extractVariableName(post.expression);
+      const type = inferType(post.expression);
+      lines.push(`  post: (${varName}: ${type}) => boolean;`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateRust(intent) {
+  const lines = [
+    `${colors.gray}// Generated Rust${colors.reset}`,
+    `pub trait ${intent.name}Contract {`
+  ];
+  if (intent.preconditions.length > 0) {
+    for (const pre of intent.preconditions) {
+      const varName = extractVariableName(pre.expression);
+      const type = inferRustType(pre.expression);
+      lines.push(`    fn check_pre(&self, ${varName}: ${type}) -> bool;`);
+    }
+  }
+  if (intent.postconditions.length > 0) {
+    for (const post of intent.postconditions) {
+      const varName = extractVariableName(post.expression);
+      const type = inferRustType(post.expression);
+      lines.push(`    fn check_post(&self, ${varName}: ${type}) -> bool;`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateGo(intent) {
+  const lines = [
+    `${colors.gray}// Generated Go${colors.reset}`,
+    `type ${intent.name}Contract interface {`
+  ];
+  if (intent.preconditions.length > 0) {
+    for (const pre of intent.preconditions) {
+      const varName = extractVariableName(pre.expression);
+      const type = inferGoType(pre.expression);
+      lines.push(`	CheckPre(${varName} ${type}) bool`);
+    }
+  }
+  if (intent.postconditions.length > 0) {
+    for (const post of intent.postconditions) {
+      const varName = extractVariableName(post.expression);
+      const type = inferGoType(post.expression);
+      lines.push(`	CheckPost(${varName} ${type}) bool`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateOpenAPI(intent) {
+  const lines = [
+    `${colors.gray}# Generated OpenAPI${colors.reset}`,
+    `openapi: 3.0.0`,
+    `paths:`,
+    `  /${intent.name.toLowerCase()}:`,
+    `    post:`,
+    `      summary: ${intent.name}`,
+    `      requestBody:`,
+    `        content:`,
+    `          application/json:`,
+    `            schema:`,
+    `              type: object`
+  ];
+  if (intent.preconditions.length > 0) {
+    lines.push(`              # Preconditions:`);
+    for (const pre of intent.preconditions) {
+      lines.push(`              # - ${pre.expression}`);
+    }
+  }
+  lines.push(`      responses:`);
+  lines.push(`        '200':`);
+  lines.push(`          description: Success`);
+  if (intent.postconditions.length > 0) {
+    lines.push(`          # Postconditions:`);
+    for (const post of intent.postconditions) {
+      lines.push(`          # - ${post.expression}`);
+    }
+  }
+  return lines.join("\n");
+}
+function extractVariableName(expression) {
+  const match = expression.match(/^(\w+)/);
+  return match ? match[1] : "input";
+}
+function inferType(expression) {
+  if (expression.includes(".length")) return "string";
+  if (expression.includes(".startsWith")) return "string";
+  if (expression.includes(".endsWith")) return "string";
+  if (expression.includes(".includes")) return "string";
+  if (expression.includes(" > ") || expression.includes(" < ")) return "number";
+  return "unknown";
+}
+function inferRustType(expression) {
+  if (expression.includes(".length") || expression.includes(".len()")) return "&str";
+  if (expression.includes(".starts_with")) return "&str";
+  if (expression.includes(" > ") || expression.includes(" < ")) return "i32";
+  return "&str";
+}
+function inferGoType(expression) {
+  if (expression.includes(".length") || expression.includes("len(")) return "string";
+  if (expression.includes(" > ") || expression.includes(" < ")) return "int";
+  return "string";
+}
+function highlightCondition(expression) {
+  return expression.replace(
+    /(\w+)\s*(>|<|>=|<=|==|!=)\s*(\d+|"[^"]*")/g,
+    `${colors.blue}$1${colors.reset} ${colors.yellow}$2${colors.reset} ${colors.green}$3${colors.reset}`
+  ).replace(/\b(true|false)\b/g, `${colors.magenta}$1${colors.reset}`).replace(/\.(length|startsWith|endsWith|includes)/g, `.${colors.cyan}$1${colors.reset}`);
+}
+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 commands = type === "meta" ? metaCommands : islCommands;
+  const names = commands.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 = [
+  { text: "intent", type: "keyword", description: "Define an intent" },
+  { text: "behavior", type: "keyword", description: "Define a behavior" },
+  { text: "pre", type: "keyword", description: "Precondition" },
+  { text: "post", type: "keyword", description: "Postcondition" },
+  { text: "invariant", type: "keyword", description: "Invariant" },
+  { 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" }
+];
+var META_COMMANDS = metaCommands.map((cmd) => ({
+  text: `.${cmd.name}`,
+  type: "command",
+  description: cmd.description
+}));
+var ISL_COMMANDS = islCommands.map((cmd) => ({
+  text: `:${cmd.name}`,
+  type: "command",
+  description: cmd.description
+}));
+var COMMANDS = [...META_COMMANDS, ...ISL_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.completeISLCommand(trimmed);
+    }
+    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
+    };
+    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.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;
+        console.log("\n" + formatWarning("Input cancelled"));
+        this.rl.setPrompt(PROMPT);
+        this.rl.prompt();
+      } else {
+        console.log("\n" + formatWarning("Use .exit or :quit to exit"));
+        this.rl.prompt();
+      }
+    });
+  }
+  /**
+   * 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
+`;
+    console.log(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.handleMetaCommand(trimmed);
+      return;
+    }
+    if (trimmed.startsWith(":") && this.buffer.length === 0) {
+      this.handleISLCommand(trimmed);
+      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 meta command (. prefix)
+   */
+  handleMetaCommand(input) {
+    const parts = input.slice(1).split(/\s+/);
+    const cmdName = parts[0]?.toLowerCase() || "";
+    const args = parts.slice(1);
+    const command = metaCommands.find(
+      (c) => c.name === cmdName || c.aliases.includes(cmdName)
+    );
+    if (command) {
+      this.history.add(input);
+      const result = command.handler(args, this.session, this);
+      if (result.output) {
+        console.log(result.output);
+      }
+      if (result.exit) {
+        this.exit();
+      }
+    } else {
+      const suggestion = findSimilarCommand(cmdName, "meta");
+      if (suggestion) {
+        console.log(formatError(`Unknown command: .${cmdName}`));
+        console.log(formatWarning(`Did you mean: .${suggestion}?`));
+      } else {
+        console.log(formatError(`Unknown command: .${cmdName}`));
+        console.log(`Type ${colors.cyan}.help${colors.reset} for available commands`);
+      }
+    }
+  }
+  /**
+   * Handle an ISL command (: prefix)
+   */
+  handleISLCommand(input) {
+    const parts = input.slice(1).split(/\s+/);
+    const cmdName = parts[0]?.toLowerCase() || "";
+    const args = parts.slice(1);
+    const command = islCommands.find(
+      (c) => c.name === cmdName || c.aliases.includes(cmdName)
+    );
+    if (command) {
+      this.history.add(input);
+      const result = command.handler(args, this.session, this);
+      if (result.output) {
+        console.log(result.output);
+      }
+    } else {
+      const suggestion = findSimilarCommand(cmdName, "isl");
+      if (suggestion) {
+        console.log(formatError(`Unknown command: :${cmdName}`));
+        console.log(formatWarning(`Did you mean: :${suggestion}?`));
+      } else {
+        console.log(formatError(`Unknown command: :${cmdName}`));
+        console.log(`Type ${colors.cyan}.help${colors.reset} for available commands`);
+      }
+    }
+  }
+  /**
+   * Evaluate ISL code
+   */
+  evaluate(code) {
+    try {
+      const trimmed = code.trim();
+      if (trimmed.startsWith("intent ")) {
+        this.evaluateIntent(trimmed);
+        return;
+      }
+      if (trimmed.startsWith("behavior ")) {
+        this.evaluateIntent(trimmed);
+        return;
+      }
+      console.log(formatWarning(`Cannot evaluate: ${trimmed.split("\n")[0]}...`));
+      console.log(`Use ${colors.cyan}intent Name { ... }${colors.reset} to define an intent`);
+    } 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(", ")})` : "";
+      console.log(formatSuccess(`Intent '${intent.name}' defined${summary}`));
+    } else {
+      const behaviorMatch = code.match(/^behavior\s+(\w+)\s*\{([\s\S]*)\}$/);
+      if (behaviorMatch) {
+        const name = behaviorMatch[1];
+        const body = behaviorMatch[2];
+        const intent2 = {
+          name,
+          preconditions: [],
+          postconditions: [],
+          invariants: [],
+          scenarios: [],
+          rawSource: code
+        };
+        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) {
+              intent2.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) {
+              intent2.postconditions.push({ expression: expr });
+            }
+          }
+        }
+        this.session.defineIntent(intent2);
+        const preCount = intent2.preconditions.length;
+        const postCount = intent2.postconditions.length;
+        const parts = [];
+        if (preCount > 0) parts.push(`${preCount} pre`);
+        if (postCount > 0) parts.push(`${postCount} post`);
+        const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+        console.log(formatSuccess(`Intent '${intent2.name}' defined${summary}`));
+      } else {
+        this.printParseError(code, "Failed to parse intent definition");
+      }
+    }
+  }
+  /**
+   * Print a parse error with location info
+   */
+  printParseError(code, message, line, column) {
+    console.log(formatError(message));
+    if (line !== void 0 && column !== void 0) {
+      const lines = code.split("\n");
+      const errorLine = lines[line - 1] || "";
+      console.log(`  ${colors.gray}${line} |${colors.reset} ${errorLine}`);
+      console.log(`  ${colors.gray}${" ".repeat(String(line).length)} |${colors.reset} ${" ".repeat(column - 1)}${colors.red}^${colors.reset}`);
+    } else {
+      const firstLine = code.split("\n")[0];
+      if (firstLine) {
+        console.log(`  ${colors.gray}>${colors.reset} ${firstLine}`);
+      }
+    }
+  }
+  /**
+   * Print an error
+   */
+  printError(error) {
+    if (error instanceof Error) {
+      console.log(formatError(error.message));
+      if (this.options.verbose && error.stack) {
+        console.log(colors.gray + error.stack + colors.reset);
+      }
+    } else {
+      console.log(formatError(String(error)));
+    }
+  }
+  /**
+   * Exit the REPL
+   */
+  exit() {
+    this.running = false;
+    this.history.save();
+    console.log(`
+${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(".")) {
+      const parts = trimmed.slice(1).split(/\s+/);
+      const cmdName = parts[0]?.toLowerCase() || "";
+      const args = parts.slice(1);
+      const command = metaCommands.find(
+        (c) => c.name === cmdName || c.aliases.includes(cmdName)
+      );
+      if (command) {
+        const result = command.handler(args, this.session, this);
+        return { success: true, output: result.output };
+      }
+      return { success: false, error: `Unknown command: .${cmdName}` };
+    }
+    if (trimmed.startsWith(":")) {
+      const parts = trimmed.slice(1).split(/\s+/);
+      const cmdName = parts[0]?.toLowerCase() || "";
+      const args = parts.slice(1);
+      const command = islCommands.find(
+        (c) => c.name === cmdName || c.aliases.includes(cmdName)
+      );
+      if (command) {
+        const result = command.handler(args, 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" };
+  }
+};
+function startREPL(options) {
+  const repl = new ISLREPL(options);
+  repl.start();
+  return repl;
+}
+
+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, metaCommands, startREPL, stripColors, wrapText };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map