@isl-lang/repl 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -47,6 +47,12 @@ var Session = class {
   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,
@@ -324,6 +330,97 @@ var Session = class {
     }
   }
   // ─────────────────────────────────────────────────────────────────────────
+  // 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
   // ─────────────────────────────────────────────────────────────────────────
   /**
@@ -334,6 +431,9 @@ var Session = class {
     this.variables.clear();
     this.lastResult = void 0;
     this.loadedFiles.clear();
+    this.evalContext = {};
+    this.preContext = null;
+    this.domainAST = null;
   }
   /**
    * Get session summary
@@ -747,32 +847,158 @@ function drawBox(lines, title) {
 }
 
 // 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 help for commands",
+    description: "Show commands",
     usage: ".help [command]",
-    handler: (args, session) => {
+    handler: (args) => {
       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) {
+        const cmdName = args[0].toLowerCase().replace(/^\./, "");
+        const cmd = metaCommands.find(
+          (c) => c.name === cmdName || c.aliases.includes(cmdName)
+        );
+        if (cmd) {
           return {
             output: [
-              `${colors.cyan}:${islCmd.name}${colors.reset} - ${islCmd.description}`,
-              `Usage: ${islCmd.usage}`,
-              islCmd.aliases.length > 0 ? `Aliases: ${islCmd.aliases.map((a) => ":" + a).join(", ")}` : ""
+              `${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")
           };
         }
@@ -780,194 +1006,232 @@ var metaCommands = [
       }
       const lines = [
         "",
-        `${colors.bold}Meta Commands${colors.reset} ${colors.gray}(REPL control)${colors.reset}`,
+        `${colors.bold}REPL Commands${colors.reset}`,
         "",
-        ...metaCommands.map((c) => `  ${colors.cyan}.${c.name.padEnd(10)}${colors.reset} ${c.description}`),
+        ...metaCommands.map(
+          (c) => `  ${colors.cyan}.${c.name.padEnd(12)}${colors.reset} ${c.description}`
+        ),
         "",
-        `${colors.bold}ISL Commands${colors.reset} ${colors.gray}(specification operations)${colors.reset}`,
+        `${colors.bold}ISL Input${colors.reset}`,
         "",
-        ...islCommands.map((c) => `  ${colors.cyan}:${c.name.padEnd(10)}${colors.reset} ${c.description}`),
+        `  Type ISL directly \u2014 multi-line supported (braces auto-detect):`,
         "",
-        `${colors.bold}ISL Syntax${colors.reset}`,
-        "",
-        `  ${colors.yellow}intent${colors.reset} Name {`,
-        `    ${colors.magenta}pre${colors.reset}: condition`,
-        `    ${colors.magenta}post${colors.reset}: condition`,
+        `  ${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 detailed help.`,
+        `Type ${colors.cyan}.help <command>${colors.reset} for details.`,
         ""
       ];
       return { output: lines.join("\n") };
     }
   },
+  // ─── .parse ─────────────────────────────────────────────────────────────
   {
-    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",
+    name: "parse",
+    aliases: ["p", "ast"],
+    description: "Parse ISL and show AST",
+    usage: ".parse <isl>",
     handler: (args, session) => {
-      session.clear();
-      return { output: formatSuccess("Session cleared") };
+      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: "history",
-    aliases: ["hist"],
-    description: "Show command history",
-    usage: ".history [n]",
+    name: "eval",
+    aliases: ["e"],
+    description: "Evaluate expression against context",
+    usage: ".eval <expression>",
     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 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 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") };
+      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)}`
+      };
     }
-  }
-];
-var islCommands = [
+  },
+  // ─── .check ─────────────────────────────────────────────────────────────
   {
     name: "check",
     aliases: ["c"],
-    description: "Type check an intent",
-    usage: ":check <intent>",
+    description: "Type check the current session",
+    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 { ... }") };
+      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 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("");
+        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 intentName = args[0];
-      const intent = session.getIntent(intentName);
-      if (!intent) {
-        const available = session.getIntentNames().join(", ") || "(none)";
+      const intents = session.getAllIntents();
+      if (intents.length === 0) {
         return {
-          output: formatError(`Unknown intent: ${intentName}
-Available: ${available}`)
+          output: formatWarning("No intents defined. Write ISL or use .load <file>")
         };
       }
-      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}`);
+      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 code from an intent",
-    usage: ":gen <target> <intent>",
+    description: "Generate TypeScript from intent",
+    usage: ".gen [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)";
+      const intents = args.length > 0 ? [session.getIntent(args[0])].filter(Boolean) : session.getAllIntents();
+      if (intents.length === 0) {
         return {
-          output: formatError(`Unknown intent: ${intentName}
-Available: ${available}`)
+          output: args.length > 0 ? formatError(`Unknown intent: ${args[0]}
+Available: ${session.getIntentNames().join(", ") || "(none)"}`) : formatWarning("No intents defined. Write ISL or use .load <file>")
         };
       }
-      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`)
-          };
+      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 intents from a file",
-    usage: ":load <file.isl>",
+    description: "Load an .isl file",
+    usage: ".load <file.isl>",
     handler: (args, session) => {
       if (args.length === 0) {
-        return { output: "Usage: :load <file.isl>" };
+        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");
+      const resolvedPath = path__namespace.isAbsolute(filePath) ? filePath : path__namespace.resolve(process.cwd(), filePath);
+      if (!fs2__namespace.existsSync(resolvedPath)) {
+        return { output: formatError(`File not found: ${resolvedPath}`) };
+      }
       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 = fs2__namespace.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__namespace.basename(filePath)}`
+              )
+            };
+          }
+        } catch {
         }
-        const content = fs4.readFileSync(resolvedPath, "utf-8");
         const intentRegex = /(?:intent|behavior)\s+(\w+)\s*\{[^}]*(?:\{[^}]*\}[^}]*)*\}/g;
         let match;
         let count = 0;
@@ -979,37 +1243,125 @@ Available: typescript, rust, go, openapi`)
           }
         }
         if (count === 0) {
-          return { output: formatWarning("No intents found in file") };
+          return { output: formatWarning("No intents/behaviors found in file") };
         }
         return {
-          output: formatSuccess(`Loaded ${count} intent(s) from ${filePath}`)
+          output: formatSuccess(`Loaded ${count} intent(s) from ${path__namespace.basename(filePath)}`)
         };
       } catch (error) {
         return {
-          output: formatError(`Failed to load: ${error instanceof Error ? error.message : String(error)}`)
+          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 all defined intents",
-    usage: ":list",
-    handler: (args, session) => {
+    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 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`);
+        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}`);
       }
@@ -1017,31 +1369,26 @@ Available: typescript, rust, go, openapi`)
       return { output: lines.join("\n") };
     }
   },
+  // ─── .inspect ───────────────────────────────────────────────────────────
   {
     name: "inspect",
     aliases: ["i", "show"],
     description: "Show full details of an intent",
-    usage: ":inspect <intent>",
+    usage: ".inspect [intent]",
     handler: (args, session) => {
       if (args.length === 0) {
         const summary = session.getSummary();
-        const files = session.getLoadedFiles();
+        const ctx = session.getEvalContext();
         const lines = [
           "",
           `${colors.bold}Session Summary${colors.reset}`,
           "",
           `  Intents:    ${summary.intentCount}`,
           `  Variables:  ${summary.variableCount}`,
-          `  History:    ${summary.historyCount} entries`
+          `  Context:    ${Object.keys(ctx).length} keys`,
+          `  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];
@@ -1056,178 +1403,18 @@ Available: ${available}`)
       return { output: formatIntent(intent) };
     }
   },
+  // ─── .exit ──────────────────────────────────────────────────────────────
   {
-    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)}`)
-        };
-      }
+    name: "exit",
+    aliases: ["quit", "q"],
+    description: "Exit the REPL",
+    usage: ".exit",
+    handler: () => {
+      return { exit: true };
     }
   }
 ];
-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}`);
-}
+var islCommands = [];
 function levenshteinDistance(a, b) {
   const matrix = [];
   for (let i = 0; i <= b.length; i++) {
@@ -1248,9 +1435,8 @@ function levenshteinDistance(a, b) {
   }
   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]);
+function findSimilarCommand(input, _type) {
+  const names = metaCommands.flatMap((c) => [c.name, ...c.aliases]);
   let bestMatch = null;
   let bestDistance = Infinity;
   for (const name of names) {
@@ -1265,11 +1451,31 @@ function findSimilarCommand(input, type) {
 
 // src/completions.ts
 var KEYWORDS = [
-  { text: "intent", type: "keyword", description: "Define an intent" },
+  // 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" },
@@ -1279,19 +1485,16 @@ var KEYWORDS = [
   { 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: "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 = islCommands.map((cmd) => ({
-  text: `:${cmd.name}`,
-  type: "command",
-  description: cmd.description
-}));
-var COMMANDS = [...META_COMMANDS, ...ISL_COMMANDS];
+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" },
@@ -1317,7 +1520,7 @@ var CompletionProvider = class {
       return this.completeMetaCommand(trimmed);
     }
     if (trimmed.startsWith(":")) {
-      return this.completeISLCommand(trimmed);
+      return this.completeMetaCommand("." + trimmed.slice(1));
     }
     return this.completeExpression(trimmed);
   }
@@ -1494,7 +1697,10 @@ var ISLREPL = class {
     this.options = {
       colors: options.colors !== false,
       verbose: options.verbose ?? false,
-      historyFile: options.historyFile
+      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({
@@ -1508,6 +1714,11 @@ var ISLREPL = class {
   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__namespace.createInterface({
       input: process.stdin,
@@ -1532,15 +1743,71 @@ var ISLREPL = class {
       if (this.buffer.length > 0) {
         this.buffer = [];
         this.braceCount = 0;
-        console.log("\n" + formatWarning("Input cancelled"));
+        process.stdout.write("\n" + formatWarning("Input cancelled") + "\n");
         this.rl.setPrompt(PROMPT);
         this.rl.prompt();
       } else {
-        console.log("\n" + formatWarning("Use .exit or :quit to exit"));
+        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
    */
@@ -1560,7 +1827,7 @@ ${colors.cyan}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
 ${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);
+    process.stdout.write(banner);
   }
   /**
    * Handle a line of input
@@ -1571,11 +1838,11 @@ Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${color
       return;
     }
     if (trimmed.startsWith(".") && this.buffer.length === 0) {
-      this.handleMetaCommand(trimmed);
+      this.handleDotCommand(trimmed);
       return;
     }
     if (trimmed.startsWith(":") && this.buffer.length === 0) {
-      this.handleISLCommand(trimmed);
+      this.handleDotCommand("." + trimmed.slice(1));
       return;
     }
     this.braceCount += (line.match(/\{/g) || []).length;
@@ -1591,78 +1858,134 @@ Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${color
     }
   }
   /**
-   * Handle a meta command (. prefix)
+   * Handle a dot command (. prefix)
    */
-  handleMetaCommand(input) {
+  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 result = command.handler(args, this.session, this);
+      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) {
-        console.log(result.output);
+        process.stdout.write(result.output + "\n");
       }
       if (result.exit) {
         this.exit();
       }
     } else {
-      const suggestion = findSimilarCommand(cmdName, "meta");
+      const suggestion = findSimilarCommand(cmdName);
       if (suggestion) {
-        console.log(formatError(`Unknown command: .${cmdName}`));
-        console.log(formatWarning(`Did you mean: .${suggestion}?`));
+        process.stdout.write(formatError(`Unknown command: .${cmdName}`) + "\n");
+        process.stdout.write(formatWarning(`Did you mean: .${suggestion}?`) + "\n");
       } else {
-        console.log(formatError(`Unknown command: .${cmdName}`));
-        console.log(`Type ${colors.cyan}.help${colors.reset} for available commands`);
+        process.stdout.write(formatError(`Unknown command: .${cmdName}`) + "\n");
+        process.stdout.write(`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 ISL code (multi-line input or bare expressions)
    */
   evaluate(code) {
     try {
       const trimmed = code.trim();
-      if (trimmed.startsWith("intent ")) {
+      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("behavior ")) {
-        this.evaluateIntent(trimmed);
+      if (trimmed.startsWith("domain ")) {
+        process.stdout.write(formatSuccess("Parsed domain block") + "\n");
         return;
       }
-      console.log(formatWarning(`Cannot evaluate: ${trimmed.split("\n")[0]}...`));
-      console.log(`Use ${colors.cyan}intent Name { ... }${colors.reset} to define an intent`);
+      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);
     }
@@ -1682,13 +2005,15 @@ Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${color
       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}`));
+      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 intent2 = {
+        const newIntent = {
           name,
           preconditions: [],
           postconditions: [],
@@ -1698,51 +2023,28 @@ Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${color
         };
         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 });
-            }
+          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) {
-          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 });
-            }
+          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(intent2);
-        const preCount = intent2.preconditions.length;
-        const postCount = intent2.postconditions.length;
+        this.session.defineIntent(newIntent);
         const parts = [];
-        if (preCount > 0) parts.push(`${preCount} pre`);
-        if (postCount > 0) parts.push(`${postCount} post`);
+        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(", ")})` : "";
-        console.log(formatSuccess(`Intent '${intent2.name}' defined${summary}`));
+        process.stdout.write(
+          formatSuccess(`Intent '${name}' defined${summary}`) + "\n"
+        );
       } 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}`);
+        process.stdout.write(formatError("Failed to parse intent definition") + "\n");
       }
     }
   }
@@ -1751,12 +2053,12 @@ Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${color
    */
   printError(error) {
     if (error instanceof Error) {
-      console.log(formatError(error.message));
+      process.stdout.write(formatError(error.message) + "\n");
       if (this.options.verbose && error.stack) {
-        console.log(colors.gray + error.stack + colors.reset);
+        process.stdout.write(colors.gray + error.stack + colors.reset + "\n");
       }
     } else {
-      console.log(formatError(String(error)));
+      process.stdout.write(formatError(String(error)) + "\n");
     }
   }
   /**
@@ -1765,8 +2067,9 @@ Type ${colors.cyan}.help${colors.reset} for commands, ${colors.cyan}.exit${color
   exit() {
     this.running = false;
     this.history.save();
-    console.log(`
-${colors.yellow}Goodbye!${colors.reset}`);
+    process.stdout.write(`
+${colors.yellow}Goodbye!${colors.reset}
+`);
     if (this.rl) {
       this.rl.close();
     }
@@ -1789,31 +2092,21 @@ ${colors.yellow}Goodbye!${colors.reset}`);
    */
   async executeOnce(input) {
     const trimmed = input.trim();
-    if (trimmed.startsWith(".")) {
-      const parts = trimmed.slice(1).split(/\s+/);
+    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 args = parts.slice(1);
+      const rawArgs = normalized.slice(1 + (cmdName.length || 0)).trim();
       const command = metaCommands.find(
         (c) => c.name === cmdName || c.aliases.includes(cmdName)
       );
       if (command) {
-        const result = command.handler(args, this.session, this);
+        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(":")) {
-      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}` };
+      return { success: false, error: `Unknown command: ${cmdName}` };
     }
     if (trimmed.startsWith("intent ") || trimmed.startsWith("behavior ")) {
       const intent = this.session.parseIntent(trimmed);
@@ -1826,12 +2119,135 @@ ${colors.yellow}Goodbye!${colors.reset}`);
     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();
+}
+
 exports.COMMANDS = COMMANDS;
 exports.CompletionProvider = CompletionProvider;
 exports.History = History;
@@ -1859,6 +2275,7 @@ exports.formatWarning = formatWarning;
 exports.highlightExpression = highlightExpression;
 exports.highlightISL = highlightISL;
 exports.islCommands = islCommands;
+exports.main = main;
 exports.metaCommands = metaCommands;
 exports.startREPL = startREPL;
 exports.stripColors = stripColors;