Phase 8: REPL, printing, source maps, and nREPL server

- IPrintWithWriter protocol + CljElixir.Printer module with pr-str,
  print-str, pr, prn for all BEAM types (EDN-like output)
- Source-mapped error messages: line/col metadata from reader now
  propagated through transformer into Elixir AST for accurate error
  locations in .clje files
- Interactive REPL (mix clje.repl) with multi-line input detection,
  history, bindings persistence, and pr-str formatted output
- nREPL server (mix clje.nrepl) with TCP transport, Bencode wire
  protocol, session management, and core operations (clone, close,
  eval, describe, ls-sessions, load-file, interrupt, completions).
  Writes .nrepl-port for editor auto-discovery.

92 new tests (699 total, 0 failures).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

lib/clj_elixir/nrepl/bencode.ex

@@ -0,0 +1,96 @@
+defmodule CljElixir.NRepl.Bencode do
+  @moduledoc "Bencode encoder/decoder for nREPL wire protocol."
+
+  # --- Encoder ---
+
+  def encode(data) when is_binary(data) do
+    "#{byte_size(data)}:#{data}"
+  end
+
+  def encode(data) when is_integer(data) do
+    "i#{data}e"
+  end
+
+  def encode(data) when is_list(data) do
+    "l" <> Enum.map_join(data, "", &encode/1) <> "e"
+  end
+
+  def encode(data) when is_map(data) do
+    sorted = data |> Enum.sort_by(fn {k, _} -> to_string(k) end)
+
+    "d" <>
+      Enum.map_join(sorted, "", fn {k, v} ->
+        encode(to_string(k)) <> encode(v)
+      end) <> "e"
+  end
+
+  def encode(data) when is_atom(data) do
+    encode(Atom.to_string(data))
+  end
+
+  # --- Decoder ---
+
+  def decode(data) when is_binary(data) do
+    {result, _rest} = decode_one(data)
+    result
+  end
+
+  def decode_all(data) do
+    decode_all(data, [])
+  end
+
+  defp decode_all("", acc), do: Enum.reverse(acc)
+
+  defp decode_all(data, acc) do
+    {result, rest} = decode_one(data)
+    decode_all(rest, [result | acc])
+  end
+
+  # Public so the TCP server can call it for streaming decode
+  def decode_one("i" <> rest) do
+    {num_str, "e" <> rest2} = split_at_char(rest, ?e)
+    {String.to_integer(num_str), rest2}
+  end
+
+  def decode_one("l" <> rest) do
+    decode_list(rest, [])
+  end
+
+  def decode_one("d" <> rest) do
+    decode_dict(rest, %{})
+  end
+
+  def decode_one(data) do
+    # String: <length>:<data>
+    {len_str, ":" <> rest} = split_at_char(data, ?:)
+    len = String.to_integer(len_str)
+    <<str::binary-size(len), rest2::binary>> = rest
+    {str, rest2}
+  end
+
+  defp decode_list("e" <> rest, acc), do: {Enum.reverse(acc), rest}
+
+  defp decode_list(data, acc) do
+    {item, rest} = decode_one(data)
+    decode_list(rest, [item | acc])
+  end
+
+  defp decode_dict("e" <> rest, acc), do: {acc, rest}
+
+  defp decode_dict(data, acc) do
+    {key, rest} = decode_one(data)
+    {value, rest2} = decode_one(rest)
+    decode_dict(rest2, Map.put(acc, key, value))
+  end
+
+  defp split_at_char(data, char) do
+    case :binary.match(data, <<char>>) do
+      {pos, 1} ->
+        <<before::binary-size(pos), _::8, rest::binary>> = data
+        {before, <<char, rest::binary>>}
+
+      :nomatch ->
+        {data, ""}
+    end
+  end
+end

lib/clj_elixir/nrepl/handler.ex

@@ -0,0 +1,110 @@
+defmodule CljElixir.NRepl.Handler do
+  @moduledoc "Handles nREPL protocol messages."
+
+  alias CljElixir.NRepl.SessionManager
+
+  def handle(msg, session_manager) do
+    op = Map.get(msg, "op")
+    id = Map.get(msg, "id", "unknown")
+    session = Map.get(msg, "session")
+
+    case op do
+      "clone" -> handle_clone(id, session, session_manager)
+      "close" -> handle_close(id, session, session_manager)
+      "eval" -> handle_eval(msg, id, session, session_manager)
+      "describe" -> handle_describe(id, session)
+      "ls-sessions" -> handle_ls_sessions(id, session_manager)
+      "load-file" -> handle_load_file(msg, id, session, session_manager)
+      "interrupt" -> handle_interrupt(id, session)
+      "completions" -> handle_completions(msg, id, session)
+      _ -> [%{"id" => id, "session" => session || "", "status" => ["done", "error", "unknown-op"]}]
+    end
+  end
+
+  defp handle_clone(id, _session, manager) do
+    new_id = SessionManager.create_session(manager)
+    [%{"id" => id, "new-session" => new_id, "status" => ["done"]}]
+  end
+
+  defp handle_close(id, session, manager) do
+    SessionManager.close_session(manager, session)
+    [%{"id" => id, "session" => session, "status" => ["done"]}]
+  end
+
+  defp handle_eval(msg, id, session, manager) do
+    code = Map.get(msg, "code", "")
+
+    # Capture stdout inside the Agent process where eval actually runs
+    {output, result} = SessionManager.eval_with_capture(manager, session, code)
+
+    responses = []
+
+    # Send stdout if any
+    responses =
+      if output != "" do
+        responses ++ [%{"id" => id, "session" => session, "out" => output}]
+      else
+        responses
+      end
+
+    # Send value or error
+    responses =
+      case result do
+        {:ok, value} ->
+          responses ++ [%{"id" => id, "session" => session, "value" => value, "ns" => "user"}]
+
+        {:error, error} ->
+          responses ++
+            [%{"id" => id, "session" => session, "err" => error, "status" => ["eval-error"]}]
+      end
+
+    # Send done
+    responses ++ [%{"id" => id, "session" => session, "status" => ["done"]}]
+  end
+
+  defp handle_describe(id, session) do
+    [
+      %{
+        "id" => id,
+        "session" => session || "",
+        "status" => ["done"],
+        "ops" => %{
+          "clone" => %{},
+          "close" => %{},
+          "eval" => %{},
+          "describe" => %{},
+          "ls-sessions" => %{},
+          "load-file" => %{},
+          "interrupt" => %{},
+          "completions" => %{}
+        },
+        "versions" => %{
+          "clj-elixir" => %{"major" => 0, "minor" => 1, "incremental" => 0},
+          "nrepl" => %{"major" => 1, "minor" => 0, "incremental" => 0}
+        }
+      }
+    ]
+  end
+
+  defp handle_ls_sessions(id, manager) do
+    sessions = SessionManager.list_sessions(manager)
+    [%{"id" => id, "sessions" => sessions, "status" => ["done"]}]
+  end
+
+  defp handle_load_file(msg, id, session, manager) do
+    code = Map.get(msg, "file", "")
+    handle_eval(Map.put(msg, "code", code), id, session, manager)
+  end
+
+  defp handle_interrupt(id, session) do
+    # Not truly implemented -- just acknowledge
+    [%{"id" => id, "session" => session, "status" => ["done"]}]
+  end
+
+  defp handle_completions(msg, id, session) do
+    _prefix = Map.get(msg, "prefix", "")
+    # Basic completions -- return empty for now, can be extended later
+    [%{"id" => id, "session" => session || "", "completions" => [], "status" => ["done"]}]
+  end
+
+end

lib/clj_elixir/nrepl/server.ex

@@ -0,0 +1,150 @@
+defmodule CljElixir.NRepl.Server do
+  @moduledoc """
+  nREPL TCP server for CljElixir.
+
+  Listens on a configurable port and handles nREPL protocol messages
+  over TCP using Bencode encoding.
+  """
+
+  use GenServer
+  require Logger
+
+  alias CljElixir.NRepl.{Bencode, Handler, SessionManager}
+
+  defstruct [:listen_socket, :port, :session_manager]
+
+  def start_link(opts \\ []) do
+    port = Keyword.get(opts, :port, 0)
+    GenServer.start_link(__MODULE__, port, opts)
+  end
+
+  def port(server) do
+    GenServer.call(server, :port)
+  end
+
+  # --- Callbacks ---
+
+  @impl true
+  def init(port) do
+    {:ok, manager} = SessionManager.start_link()
+
+    # Open TCP listener
+    opts = [:binary, packet: :raw, active: false, reuseaddr: true]
+
+    case :gen_tcp.listen(port, opts) do
+      {:ok, listen_socket} ->
+        # Get actual port (important when port=0)
+        {:ok, actual_port} = :inet.port(listen_socket)
+
+        state = %__MODULE__{
+          listen_socket: listen_socket,
+          port: actual_port,
+          session_manager: manager
+        }
+
+        # Start accepting connections in a separate process
+        spawn_link(fn -> accept_loop(listen_socket, manager) end)
+
+        Logger.info("nREPL server started on port #{actual_port}")
+        {:ok, state}
+
+      {:error, reason} ->
+        {:stop, reason}
+    end
+  end
+
+  @impl true
+  def handle_call(:port, _from, state) do
+    {:reply, state.port, state}
+  end
+
+  @impl true
+  def terminate(_reason, state) do
+    if state.listen_socket do
+      :gen_tcp.close(state.listen_socket)
+    end
+
+    :ok
+  end
+
+  # --- Connection handling ---
+
+  defp accept_loop(listen_socket, manager) do
+    case :gen_tcp.accept(listen_socket) do
+      {:ok, client_socket} ->
+        spawn(fn -> handle_connection(client_socket, manager) end)
+        accept_loop(listen_socket, manager)
+
+      {:error, :closed} ->
+        :ok
+
+      {:error, reason} ->
+        Logger.error("Accept error: #{inspect(reason)}")
+        :ok
+    end
+  end
+
+  defp handle_connection(socket, manager) do
+    case read_message(socket, "") do
+      {:ok, msg, rest} ->
+        responses = Handler.handle(msg, manager)
+
+        Enum.each(responses, fn response ->
+          encoded = Bencode.encode(response)
+          :gen_tcp.send(socket, encoded)
+        end)
+
+        handle_connection_with_buffer(socket, manager, rest)
+
+      {:error, _reason} ->
+        :gen_tcp.close(socket)
+    end
+  end
+
+  defp handle_connection_with_buffer(socket, manager, buffer) do
+    case try_decode(buffer) do
+      {:ok, msg, rest} ->
+        responses = Handler.handle(msg, manager)
+
+        Enum.each(responses, fn response ->
+          encoded = Bencode.encode(response)
+          :gen_tcp.send(socket, encoded)
+        end)
+
+        handle_connection_with_buffer(socket, manager, rest)
+
+      :incomplete ->
+        case :gen_tcp.recv(socket, 0) do
+          {:ok, data} ->
+            handle_connection_with_buffer(socket, manager, buffer <> data)
+
+          {:error, _} ->
+            :gen_tcp.close(socket)
+        end
+    end
+  end
+
+  defp read_message(socket, buffer) do
+    case try_decode(buffer) do
+      {:ok, msg, rest} ->
+        {:ok, msg, rest}
+
+      :incomplete ->
+        case :gen_tcp.recv(socket, 0) do
+          {:ok, data} -> read_message(socket, buffer <> data)
+          {:error, reason} -> {:error, reason}
+        end
+    end
+  end
+
+  defp try_decode(data) when byte_size(data) == 0, do: :incomplete
+
+  defp try_decode(data) do
+    try do
+      {msg, rest} = Bencode.decode_one(data)
+      {:ok, msg, rest}
+    rescue
+      _ -> :incomplete
+    end
+  end
+end

lib/clj_elixir/nrepl/session.ex

@@ -0,0 +1,149 @@
+defmodule CljElixir.NRepl.SessionManager do
+  @moduledoc "Manages nREPL sessions with independent REPL state."
+
+  use GenServer
+
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, %{}, opts)
+  end
+
+  @impl true
+  def init(_) do
+    {:ok, %{sessions: %{}}}
+  end
+
+  def create_session(manager) do
+    GenServer.call(manager, :create_session)
+  end
+
+  def close_session(manager, session_id) do
+    GenServer.call(manager, {:close_session, session_id})
+  end
+
+  def list_sessions(manager) do
+    GenServer.call(manager, :list_sessions)
+  end
+
+  def eval(manager, session_id, code) do
+    GenServer.call(manager, {:eval, session_id, code}, :infinity)
+  end
+
+  @doc "Eval with stdout capture. Returns {output, result} where result is {:ok, value} | {:error, error}."
+  def eval_with_capture(manager, session_id, code) do
+    GenServer.call(manager, {:eval_with_capture, session_id, code}, :infinity)
+  end
+
+  # --- Callbacks ---
+
+  @impl true
+  def handle_call(:create_session, _from, state) do
+    id = generate_uuid()
+    {:ok, pid} = Agent.start_link(fn -> CljElixir.REPL.new() end)
+    new_sessions = Map.put(state.sessions, id, pid)
+    {:reply, id, %{state | sessions: new_sessions}}
+  end
+
+  @impl true
+  def handle_call({:close_session, id}, _from, state) do
+    case Map.pop(state.sessions, id) do
+      {nil, _} ->
+        {:reply, :not_found, state}
+
+      {pid, new_sessions} ->
+        Agent.stop(pid)
+        {:reply, :ok, %{state | sessions: new_sessions}}
+    end
+  end
+
+  @impl true
+  def handle_call(:list_sessions, _from, state) do
+    {:reply, Map.keys(state.sessions), state}
+  end
+
+  @impl true
+  def handle_call({:eval, id, code}, _from, state) do
+    case Map.get(state.sessions, id) do
+      nil ->
+        {:reply, {:error, "unknown session"}, state}
+
+      pid ->
+        result =
+          Agent.get_and_update(
+            pid,
+            fn repl_state ->
+              case CljElixir.REPL.eval(code, repl_state) do
+                {:ok, value, new_state} -> {{:ok, value}, new_state}
+                {:error, error, new_state} -> {{:error, error}, new_state}
+              end
+            end,
+            :infinity
+          )
+
+        {:reply, result, state}
+    end
+  end
+
+  @impl true
+  def handle_call({:eval_with_capture, id, code}, _from, state) do
+    case Map.get(state.sessions, id) do
+      nil ->
+        {:reply, {"", {:error, "unknown session"}}, state}
+
+      pid ->
+        {output, result} =
+          Agent.get_and_update(
+            pid,
+            fn repl_state ->
+              {output, eval_result, new_state} = eval_capturing_output(code, repl_state)
+
+              {{output, eval_result}, new_state}
+            end,
+            :infinity
+          )
+
+        {:reply, {output, result}, state}
+    end
+  end
+
+  # Evaluate code while capturing stdout within the current process
+  defp eval_capturing_output(code, repl_state) do
+    {:ok, string_io} = StringIO.open("")
+    old_gl = Process.group_leader()
+    Process.group_leader(self(), string_io)
+
+    try do
+      case CljElixir.REPL.eval(code, repl_state) do
+        {:ok, value, new_state} ->
+          Process.group_leader(self(), old_gl)
+          {_input, output} = StringIO.contents(string_io)
+          StringIO.close(string_io)
+          {output, {:ok, value}, new_state}
+
+        {:error, error, new_state} ->
+          Process.group_leader(self(), old_gl)
+          {_input, output} = StringIO.contents(string_io)
+          StringIO.close(string_io)
+          {output, {:error, error}, new_state}
+      end
+    rescue
+      e ->
+        Process.group_leader(self(), old_gl)
+        StringIO.close(string_io)
+        {"", {:error, Exception.message(e)}, repl_state}
+    end
+  end
+
+  # Simple UUID v4 generation using :crypto (OTP built-in, no deps)
+  defp generate_uuid do
+    <<a::32, b::16, c::16, d::16, e::48>> = :crypto.strong_rand_bytes(16)
+
+    :io_lib.format("~8.16.0b-~4.16.0b-4~3.16.0b-~4.16.0b-~12.16.0b", [
+      a,
+      b,
+      Bitwise.band(c, 0x0FFF),
+      Bitwise.bor(Bitwise.band(d, 0x3FFF), 0x8000),
+      e
+    ])
+    |> IO.iodata_to_binary()
+  end
+end

lib/clj_elixir/printer.ex

@@ -0,0 +1,145 @@
+defmodule CljElixir.Printer do
+  @moduledoc """
+  Machine-readable printing for CljElixir values.
+
+  Produces EDN-compatible string representations:
+  - Strings: `"\"hello\""`
+  - Keywords/atoms: `":name"`
+  - Integers: `"42"`
+  - Maps: `"{:name \"Ada\", :age 30}"`
+  - Lists: `"(1 2 3)"`
+  - Vectors (PersistentVector): `"[1 2 3]"`
+  - Tuples: `"#el[:ok \"data\"]"`
+  - Sets (MapSet): `"\#{:a :b :c}"`
+  - nil: `"nil"`
+  - Booleans: `"true"` / `"false"`
+  - Records (structs): `"#RecordName{:field val, ...}"`
+  """
+
+  @doc "Convert value to machine-readable string (EDN-like)"
+  def pr_str(value) do
+    # Check if the value implements IPrintWithWriter protocol.
+    # If so, use it. Otherwise, use built-in printing.
+    if protocol_implemented?(value) do
+      try do
+        CljElixir.IPrintWithWriter.pr_writer(value, nil, nil)
+      rescue
+        _ -> do_pr_str(value)
+      end
+    else
+      do_pr_str(value)
+    end
+  end
+
+  @doc "Convert value to human-readable string"
+  def print_str(value) do
+    do_print_str(value)
+  end
+
+  # Check if IPrintWithWriter is compiled and implemented for this value
+  defp protocol_implemented?(value) do
+    case Code.ensure_loaded(CljElixir.IPrintWithWriter) do
+      {:module, _} ->
+        CljElixir.IPrintWithWriter.impl_for(value) != nil
+
+      _ ->
+        false
+    end
+  end
+
+  # --- Machine-readable (EDN) ---
+
+  defp do_pr_str(nil), do: "nil"
+  defp do_pr_str(true), do: "true"
+  defp do_pr_str(false), do: "false"
+
+  defp do_pr_str(n) when is_integer(n), do: Integer.to_string(n)
+  defp do_pr_str(n) when is_float(n), do: Float.to_string(n)
+
+  defp do_pr_str(s) when is_binary(s) do
+    "\"" <> escape_string(s) <> "\""
+  end
+
+  defp do_pr_str(a) when is_atom(a) do
+    name = Atom.to_string(a)
+
+    if String.starts_with?(name, "Elixir.") do
+      # Module name - strip Elixir. prefix
+      String.replace_prefix(name, "Elixir.", "")
+    else
+      ":" <> name
+    end
+  end
+
+  defp do_pr_str(list) when is_list(list) do
+    "(" <> Enum.map_join(list, " ", &pr_str/1) <> ")"
+  end
+
+  defp do_pr_str(%MapSet{} = set) do
+    "\#{" <> Enum.map_join(set, " ", &pr_str/1) <> "}"
+  end
+
+  # Struct handling - use runtime __struct__ check for PersistentVector/SubVector
+  # since they are .clje modules not available at compile time.
+  defp do_pr_str(%{__struct__: struct_mod} = struct) do
+    struct_name = Atom.to_string(struct_mod)
+
+    cond do
+      String.ends_with?(struct_name, "PersistentVector") ->
+        # PersistentVector - print as [...]
+        elements = apply(struct_mod, :to_list, [struct])
+        "[" <> Enum.map_join(elements, " ", &pr_str/1) <> "]"
+
+      String.ends_with?(struct_name, "SubVector") ->
+        # SubVector - print as [...]
+        elements = apply(struct_mod, :sv_to_list, [struct])
+        "[" <> Enum.map_join(elements, " ", &pr_str/1) <> "]"
+
+      true ->
+        # Generic struct/record
+        mod_name = struct_mod |> Module.split() |> List.last()
+        fields = struct |> Map.from_struct() |> Map.to_list()
+
+        "#" <>
+          mod_name <>
+          "{" <>
+          Enum.map_join(fields, ", ", fn {k, v} -> pr_str(k) <> " " <> pr_str(v) end) <>
+          "}"
+    end
+  end
+
+  # Plain map
+  defp do_pr_str(map) when is_map(map) do
+    "{" <>
+      Enum.map_join(map, ", ", fn {k, v} -> pr_str(k) <> " " <> pr_str(v) end) <>
+      "}"
+  end
+
+  defp do_pr_str(tuple) when is_tuple(tuple) do
+    elements = Tuple.to_list(tuple)
+    "#el[" <> Enum.map_join(elements, " ", &pr_str/1) <> "]"
+  end
+
+  defp do_pr_str(pid) when is_pid(pid), do: inspect(pid)
+  defp do_pr_str(ref) when is_reference(ref), do: inspect(ref)
+  defp do_pr_str(port) when is_port(port), do: inspect(port)
+  defp do_pr_str(fun) when is_function(fun), do: inspect(fun)
+
+  defp do_pr_str(other), do: inspect(other)
+
+  # --- Human-readable ---
+
+  defp do_print_str(s) when is_binary(s), do: s
+  defp do_print_str(other), do: do_pr_str(other)
+
+  # --- String escaping ---
+
+  defp escape_string(s) do
+    s
+    |> String.replace("\\", "\\\\")
+    |> String.replace("\"", "\\\"")
+    |> String.replace("\n", "\\n")
+    |> String.replace("\t", "\\t")
+    |> String.replace("\r", "\\r")
+  end
+end

lib/clj_elixir/repl.ex

@@ -0,0 +1,110 @@
+defmodule CljElixir.REPL do
+  @moduledoc """
+  CljElixir Read-Eval-Print Loop engine.
+
+  Maintains state across evaluations: bindings persist,
+  modules defined in one evaluation are available in the next.
+  """
+
+  defstruct bindings: [],
+            history: [],
+            counter: 1,
+            env: nil
+
+  @doc "Create a new REPL state"
+  def new do
+    %__MODULE__{}
+  end
+
+  @doc """
+  Evaluate a CljElixir source string in the given REPL state.
+  Returns {:ok, result_string, new_state} or {:error, error_string, new_state}.
+  """
+  def eval(source, state) do
+    opts = [
+      bindings: state.bindings,
+      file: "repl"
+    ]
+
+    case CljElixir.Compiler.eval_string(source, opts) do
+      {:ok, result, new_bindings} ->
+        result_str = CljElixir.Printer.pr_str(result)
+
+        new_state = %{state |
+          bindings: new_bindings,
+          history: [source | state.history],
+          counter: state.counter + 1
+        }
+
+        {:ok, result_str, new_state}
+
+      {:error, errors} ->
+        error_str = format_errors(errors)
+        new_state = %{state | counter: state.counter + 1}
+        {:error, error_str, new_state}
+    end
+  end
+
+  @doc "Check if input has balanced delimiters (parens, brackets, braces)"
+  def balanced?(input) do
+    input
+    |> String.graphemes()
+    |> count_delimiters(0, 0, 0, false, false)
+  end
+
+  # Count open/close delimiters, respecting strings and comments
+  defp count_delimiters([], parens, brackets, braces, _in_string, _escape) do
+    parens == 0 and brackets == 0 and braces == 0
+  end
+
+  defp count_delimiters([char | rest], p, b, br, in_string, escape) do
+    cond do
+      escape ->
+        # Previous char was \, skip this one
+        count_delimiters(rest, p, b, br, in_string, false)
+
+      char == "\\" and in_string ->
+        count_delimiters(rest, p, b, br, in_string, true)
+
+      char == "\"" and not in_string ->
+        count_delimiters(rest, p, b, br, true, false)
+
+      char == "\"" and in_string ->
+        count_delimiters(rest, p, b, br, false, false)
+
+      in_string ->
+        count_delimiters(rest, p, b, br, true, false)
+
+      char == ";" ->
+        # Comment - skip rest of line
+        rest_after_newline = Enum.drop_while(rest, &(&1 != "\n"))
+        count_delimiters(rest_after_newline, p, b, br, false, false)
+
+      char == "(" -> count_delimiters(rest, p + 1, b, br, false, false)
+      char == ")" -> count_delimiters(rest, p - 1, b, br, false, false)
+      char == "[" -> count_delimiters(rest, p, b + 1, br, false, false)
+      char == "]" -> count_delimiters(rest, p, b - 1, br, false, false)
+      char == "{" -> count_delimiters(rest, p, b, br + 1, false, false)
+      char == "}" -> count_delimiters(rest, p, b, br - 1, false, false)
+
+      true -> count_delimiters(rest, p, b, br, false, false)
+    end
+  end
+
+  defp format_errors(errors) when is_list(errors) do
+    Enum.map_join(errors, "\n", fn
+      %{message: msg, line: line} when is_integer(line) and line > 0 ->
+        "Error on line #{line}: #{msg}"
+
+      %{message: msg} ->
+        "Error: #{msg}"
+
+      other ->
+        "Error: #{inspect(other)}"
+    end)
+  end
+
+  defp format_errors(other) do
+    "Error: #{inspect(other)}"
+  end
+end

lib/clj_elixir/transformer.ex

@@ -199,12 +199,12 @@ defmodule CljElixir.Transformer do
   # ---------------------------------------------------------------------------
 
   # Dynamic vars
-  defp transform_symbol("*self*", _meta, ctx) do
-    {{:self, [], []}, ctx}
+  defp transform_symbol("*self*", meta, ctx) do
+    {{:self, elixir_meta(meta), []}, ctx}
   end
 
-  defp transform_symbol("*node*", _meta, ctx) do
-    {{:node, [], []}, ctx}
+  defp transform_symbol("*node*", meta, ctx) do
+    {{:node, elixir_meta(meta), []}, ctx}
   end
 
   # true/false/nil are also possible as symbols
@@ -213,10 +213,10 @@ defmodule CljElixir.Transformer do
   defp transform_symbol("nil", _meta, ctx), do: {nil, ctx}
 
   # Module-qualified symbol like Enum/map or io/format
-  defp transform_symbol(name, _meta, ctx) when is_binary(name) do
+  defp transform_symbol(name, meta, ctx) when is_binary(name) do
     cond do
       String.contains?(name, "/") ->
-        transform_module_call_symbol(name, ctx)
+        transform_module_call_symbol(name, meta, ctx)
 
       module_reference?(name) ->
         # Bare module reference (e.g., CljElixir.SubVector as a value)
@@ -226,7 +226,7 @@ defmodule CljElixir.Transformer do
         # Plain variable
         munged = munge_name(name)
         atom_name = String.to_atom(munged)
-        {{atom_name, [], nil}, ctx}
+        {{atom_name, elixir_meta(meta), nil}, ctx}
     end
   end
 
@@ -239,10 +239,11 @@ defmodule CljElixir.Transformer do
       String.contains?(name, ".")
   end
 
-  defp transform_module_call_symbol(name, ctx) do
+  defp transform_module_call_symbol(name, meta, ctx) do
     {mod_ast, fun_atom} = parse_module_function(name)
+    em = elixir_meta(meta)
     # Bare qualified symbol → zero-arg call (e.g., Enum/count as value)
-    ast = {{:., [], [mod_ast, fun_atom]}, [], []}
+    ast = {{:., em, [mod_ast, fun_atom]}, em, []}
     {ast, ctx}
   end
 
@@ -317,6 +318,10 @@ defmodule CljElixir.Transformer do
       {:symbol, _, "dec"} -> transform_dec(args, ctx)
       {:symbol, _, "str"} -> transform_str(args, ctx)
       {:symbol, _, "println"} -> transform_println(args, ctx)
+      {:symbol, _, "pr-str"} -> transform_pr_str(args, ctx)
+      {:symbol, _, "pr"} -> transform_pr(args, ctx)
+      {:symbol, _, "prn"} -> transform_prn(args, ctx)
+      {:symbol, _, "print-str"} -> transform_print_str(args, ctx)
       {:symbol, _, "nil?"} -> transform_nil_check(args, ctx)
       {:symbol, _, "throw"} -> transform_throw(args, ctx)
       {:symbol, _, "count"} -> transform_count(args, ctx)
@@ -382,7 +387,7 @@ defmodule CljElixir.Transformer do
 
       # --- Keyword-as-function: (:name user) ---
       kw when is_atom(kw) ->
-        transform_keyword_call(kw, args, ctx)
+        transform_keyword_call(kw, args, meta, ctx)
 
       # --- Module/function calls from symbol with / ---
       {:symbol, _, name} when is_binary(name) ->
@@ -390,18 +395,18 @@ defmodule CljElixir.Transformer do
           expand_macro(name, args, ctx)
         else
           if String.contains?(name, "/") do
-            transform_module_call(name, args, ctx)
+            transform_module_call(name, args, meta, ctx)
           else
             # Check for ->Constructor and map->Constructor
             cond do
               String.starts_with?(name, "->") and not String.starts_with?(name, "->>") ->
-                transform_positional_constructor(name, args, ctx)
+                transform_positional_constructor(name, args, meta, ctx)
 
               String.starts_with?(name, "map->") ->
-                transform_map_constructor(name, args, ctx)
+                transform_map_constructor(name, args, meta, ctx)
 
               true ->
-                transform_unqualified_call(name, args, ctx)
+                transform_unqualified_call(name, args, meta, ctx)
             end
           end
         end
@@ -418,7 +423,7 @@ defmodule CljElixir.Transformer do
   # 1. defmodule
   # ---------------------------------------------------------------------------
 
-  defp transform_defmodule(args, _meta, ctx) do
+  defp transform_defmodule(args, meta, ctx) do
     {name_form, rest} = extract_name(args)
     mod_alias = module_name_ast(name_form)
 
@@ -459,7 +464,7 @@ defmodule CljElixir.Transformer do
       end
 
     ast =
-      {:defmodule, [context: Elixir],
+      {:defmodule, [context: Elixir] ++ elixir_meta(meta),
        [mod_alias, [do: block]]}
 
     {ast, ctx}
@@ -469,7 +474,7 @@ defmodule CljElixir.Transformer do
   # 2. defn / defn-
   # ---------------------------------------------------------------------------
 
-  defp transform_defn(args, _meta, ctx, kind) do
+  defp transform_defn(args, meta, ctx, kind) do
     {name_form, rest} = extract_name(args)
     fun_name = symbol_to_atom(name_form)
 
@@ -485,6 +490,7 @@ defmodule CljElixir.Transformer do
     clauses = parse_defn_clauses(rest)
 
     def_kind = if kind == :def, do: :def, else: :defp
+    em = elixir_meta(meta)
 
     doc_ast =
       if doc do
@@ -519,12 +525,12 @@ defmodule CljElixir.Transformer do
         clause =
           case guard do
             nil ->
-              {def_kind, [], [call_with_args(fun_name, param_asts), [do: body_ast]]}
+              {def_kind, em, [call_with_args(fun_name, param_asts), [do: body_ast]]}
 
             guard_form ->
               guard_ast = transform(guard_form, fn_ctx)
 
-              {def_kind, [],
+              {def_kind, em,
                [
                  {:when, [],
                   [call_with_args(fun_name, param_asts), guard_ast]},
@@ -600,8 +606,9 @@ defmodule CljElixir.Transformer do
   # 3. fn
   # ---------------------------------------------------------------------------
 
-  defp transform_fn(args, _meta, ctx) do
+  defp transform_fn(args, meta, ctx) do
     clauses = parse_fn_clauses(args)
+    em = elixir_meta(meta)
 
     fn_clauses =
       Enum.flat_map(clauses, fn {params, rest_param, guard, body_forms} ->
@@ -632,7 +639,7 @@ defmodule CljElixir.Transformer do
         [clause]
       end)
 
-    {{:fn, [], fn_clauses}, ctx}
+    {{:fn, em, fn_clauses}, ctx}
   end
 
   defp parse_fn_clauses(args) do
@@ -739,15 +746,16 @@ defmodule CljElixir.Transformer do
   # 5. let
   # ---------------------------------------------------------------------------
 
-  defp transform_let([{:vector, _, bindings} | body], _meta, ctx) do
+  defp transform_let([{:vector, _, bindings} | body], meta, ctx) do
     binding_pairs = Enum.chunk_every(bindings, 2)
+    em = elixir_meta(meta)
 
     {binding_asts, final_ctx} =
       Enum.map_reduce(binding_pairs, ctx, fn [pattern, expr], acc ->
         pattern_ctx = %{acc | in_pattern: true}
         pat_ast = transform(pattern, pattern_ctx)
         expr_ast = transform(expr, acc)
-        match_ast = {:=, [], [pat_ast, expr_ast]}
+        match_ast = {:=, em, [pat_ast, expr_ast]}
         {match_ast, acc}
       end)
 
@@ -757,7 +765,7 @@ defmodule CljElixir.Transformer do
     ast =
       case all do
         [single] -> single
-        multiple -> {:__block__, [], multiple}
+        multiple -> {:__block__, em, multiple}
       end
 
     {ast, ctx}
@@ -767,7 +775,7 @@ defmodule CljElixir.Transformer do
   # 6. if / when / cond / case / do
   # ---------------------------------------------------------------------------
 
-  defp transform_if([test, then_form | else_form], _meta, ctx) do
+  defp transform_if([test, then_form | else_form], meta, ctx) do
     test_ast = transform(test, ctx)
     then_ast = transform(then_form, ctx)
 
@@ -777,18 +785,18 @@ defmodule CljElixir.Transformer do
         [] -> nil
       end
 
-    ast = {:if, [], [test_ast, [do: then_ast, else: else_ast]]}
+    ast = {:if, elixir_meta(meta), [test_ast, [do: then_ast, else: else_ast]]}
     {ast, ctx}
   end
 
-  defp transform_when([test | body], _meta, ctx) do
+  defp transform_when([test | body], meta, ctx) do
     test_ast = transform(test, ctx)
     body_ast = transform_body(body, ctx)
-    ast = {:if, [], [test_ast, [do: body_ast]]}
+    ast = {:if, elixir_meta(meta), [test_ast, [do: body_ast]]}
     {ast, ctx}
   end
 
-  defp transform_cond(pairs, _meta, ctx) do
+  defp transform_cond(pairs, meta, ctx) do
     clauses =
       pairs
       |> Enum.chunk_every(2)
@@ -803,11 +811,11 @@ defmodule CljElixir.Transformer do
         {:->, [], [[cond_ast], result_ast]}
       end)
 
-    ast = {:cond, [], [[do: clauses]]}
+    ast = {:cond, elixir_meta(meta), [[do: clauses]]}
     {ast, ctx}
   end
 
-  defp transform_case([val | clauses], _meta, ctx) do
+  defp transform_case([val | clauses], meta, ctx) do
     val_ast = transform(val, ctx)
     pattern_ctx = %{ctx | in_pattern: true}
 
@@ -828,11 +836,12 @@ defmodule CljElixir.Transformer do
           {:->, [], [[pat_ast], body_ast]}
       end)
 
-    ast = {:case, [], [val_ast, [do: case_clauses]]}
+    ast = {:case, elixir_meta(meta), [val_ast, [do: case_clauses]]}
     {ast, ctx}
   end
 
   defp transform_do(exprs, _meta, ctx) do
+    # transform_body handles its own block wrapping; meta not needed here
     body_ast = transform_body(exprs, ctx)
     {body_ast, ctx}
   end
@@ -841,9 +850,10 @@ defmodule CljElixir.Transformer do
   # 7. loop / recur
   # ---------------------------------------------------------------------------
 
-  defp transform_loop([{:vector, _, bindings} | body], _meta, ctx) do
+  defp transform_loop([{:vector, _, bindings} | body], meta, ctx) do
     binding_pairs = Enum.chunk_every(bindings, 2)
     arity = length(binding_pairs)
+    em = elixir_meta(meta)
 
     loop_var = unique_var(:loop_fn, ctx)
     loop_ctx = %{ctx | loop_var: loop_var, loop_arity: arity}
@@ -859,16 +869,16 @@ defmodule CljElixir.Transformer do
 
     # Pattern: loop_fn = fn loop_fn, bindings... -> body end; loop_fn.(loop_fn, init_vals...)
     fn_params = [loop_var | param_names]
-    fn_ast = {:fn, [], [{:->, [], [fn_params, body_ast]}]}
+    fn_ast = {:fn, em, [{:->, [], [fn_params, body_ast]}]}
 
-    assign = {:=, [], [loop_var, fn_ast]}
-    invoke = {{:., [], [loop_var]}, [], [loop_var | init_vals]}
+    assign = {:=, em, [loop_var, fn_ast]}
+    invoke = {{:., em, [loop_var]}, em, [loop_var | init_vals]}
 
-    ast = {:__block__, [], [assign, invoke]}
+    ast = {:__block__, em, [assign, invoke]}
     {ast, ctx}
   end
 
-  defp transform_recur(args, _meta, ctx) do
+  defp transform_recur(args, _meta_unused, ctx) do
     t_args = Enum.map(args, fn a -> transform(a, ctx) end)
 
     ast =
@@ -891,21 +901,22 @@ defmodule CljElixir.Transformer do
   # 8. def (top-level binding)
   # ---------------------------------------------------------------------------
 
-  defp transform_def([name_form, value], _meta, ctx) do
+  defp transform_def([name_form, value], meta, ctx) do
     fun_name = symbol_to_atom(name_form)
+    em = elixir_meta(meta)
 
     # Check if value looks like a schema definition
     case detect_schema(value) do
       nil ->
         val_ast = transform(value, ctx)
-        def_ast = {:def, [], [{fun_name, [], []}, [do: val_ast]]}
+        def_ast = {:def, em, [{fun_name, [], []}, [do: val_ast]]}
         {def_ast, ctx}
 
       schema_data ->
         # For schema defs, use the plain data as the runtime value
         # (avoids trying to transform schema references like PositiveInt as variables)
         val_ast = Macro.escape(schema_data)
-        def_ast = {:def, [], [{fun_name, [], []}, [do: val_ast]]}
+        def_ast = {:def, em, [{fun_name, [], []}, [do: val_ast]]}
 
         # Generate type name: "User" -> :user, "PositiveInt" -> :positive_int
         schema_name = symbol_name(name_form)
@@ -931,9 +942,10 @@ defmodule CljElixir.Transformer do
     end
   end
 
-  defp transform_def([name_form], _meta, ctx) do
+  defp transform_def([name_form], meta, ctx) do
     fun_name = symbol_to_atom(name_form)
-    ast = {:def, [], [{fun_name, [], []}, [do: nil]]}
+    em = elixir_meta(meta)
+    ast = {:def, em, [{fun_name, [], []}, [do: nil]]}
     {ast, ctx}
   end
 
@@ -941,10 +953,11 @@ defmodule CljElixir.Transformer do
   # 9. Module/function calls (FFI)
   # ---------------------------------------------------------------------------
 
-  defp transform_module_call(name, args, ctx) do
+  defp transform_module_call(name, args, meta, ctx) do
     {mod_ast, fun_atom} = parse_module_function(name)
     t_args = Enum.map(args, fn a -> transform(a, ctx) end)
-    ast = {{:., [], [mod_ast, fun_atom]}, [], t_args}
+    em = elixir_meta(meta)
+    ast = {{:., em, [mod_ast, fun_atom]}, em, t_args}
     {ast, ctx}
   end
 
@@ -982,11 +995,11 @@ defmodule CljElixir.Transformer do
   # 10. Unqualified function calls
   # ---------------------------------------------------------------------------
 
-  defp transform_unqualified_call(name, args, ctx) do
+  defp transform_unqualified_call(name, args, meta, ctx) do
     munged = munge_name(name)
     fun_atom = String.to_atom(munged)
     t_args = Enum.map(args, fn a -> transform(a, ctx) end)
-    ast = {fun_atom, [], t_args}
+    ast = {fun_atom, elixir_meta(meta), t_args}
     {ast, ctx}
   end
 
@@ -1192,7 +1205,7 @@ defmodule CljElixir.Transformer do
   # 12. Keyword-as-function
   # ---------------------------------------------------------------------------
 
-  defp transform_keyword_call(kw, args, ctx) do
+  defp transform_keyword_call(kw, args, _meta, ctx) do
     case args do
       [map_form] ->
         map_ast = transform(map_form, ctx)
@@ -1215,7 +1228,7 @@ defmodule CljElixir.Transformer do
   # 13. defprotocol
   # ---------------------------------------------------------------------------
 
-  defp transform_defprotocol(args, _meta, ctx) do
+  defp transform_defprotocol(args, meta, ctx) do
     {name_form, rest} = extract_name(args)
     proto_alias = module_name_ast(name_form)
 
@@ -1265,7 +1278,7 @@ defmodule CljElixir.Transformer do
         multiple -> {:__block__, [], multiple}
       end
 
-    ast = {:defprotocol, [context: Elixir], [proto_alias, [do: block]]}
+    ast = {:defprotocol, [context: Elixir] ++ elixir_meta(meta), [proto_alias, [do: block]]}
     {ast, ctx}
   end
 
@@ -1273,7 +1286,7 @@ defmodule CljElixir.Transformer do
   # 14. defrecord
   # ---------------------------------------------------------------------------
 
-  defp transform_defrecord(args, _meta, ctx) do
+  defp transform_defrecord(args, meta, ctx) do
     {name_form, rest} = extract_name(args)
     record_alias = module_name_ast(name_form)
     record_name = symbol_name(name_form)
@@ -1348,7 +1361,7 @@ defmodule CljElixir.Transformer do
         multiple -> {:__block__, [], multiple}
       end
 
-    ast = {:defmodule, [context: Elixir], [record_alias, [do: block]]}
+    ast = {:defmodule, [context: Elixir] ++ elixir_meta(meta), [record_alias, [do: block]]}
     {ast, new_ctx}
   end
 
@@ -1374,7 +1387,7 @@ defmodule CljElixir.Transformer do
   # 15. extend-type / extend-protocol
   # ---------------------------------------------------------------------------
 
-  defp transform_extend_type([type_form | rest], _meta, ctx) do
+  defp transform_extend_type([type_form | rest], _meta_unused, ctx) do
     type_alias = resolve_type_name(type_form)
 
     groups = parse_protocol_groups(rest)
@@ -1402,7 +1415,7 @@ defmodule CljElixir.Transformer do
     {ast, ctx}
   end
 
-  defp transform_extend_protocol([proto_form | rest], _meta, ctx) do
+  defp transform_extend_protocol([proto_form | rest], _meta_unused, ctx) do
     proto_alias = resolve_type_name(proto_form)
 
     # Parse: TypeName (fn ...) TypeName (fn ...)
@@ -1435,7 +1448,7 @@ defmodule CljElixir.Transformer do
   # 16. reify
   # ---------------------------------------------------------------------------
 
-  defp transform_reify(args, _meta, ctx) do
+  defp transform_reify(args, _meta_unused, ctx) do
     {counter, new_ctx} = bump_gensym(ctx)
     mod_name = String.to_atom("CljElixir.Reify_#{counter}")
     mod_alias = {:__aliases__, [alias: false], [mod_name]}
@@ -1475,7 +1488,7 @@ defmodule CljElixir.Transformer do
   # 17. with
   # ---------------------------------------------------------------------------
 
-  defp transform_with([{:vector, _, bindings} | body_and_else], _meta, ctx) do
+  defp transform_with([{:vector, _, bindings} | body_and_else], meta, ctx) do
     binding_pairs = Enum.chunk_every(bindings, 2)
     pattern_ctx = %{ctx | in_pattern: true}
 
@@ -1507,7 +1520,7 @@ defmodule CljElixir.Transformer do
         [do: body_ast, else: else_pairs]
       end
 
-    ast = {:with, [], with_clauses ++ [opts]}
+    ast = {:with, elixir_meta(meta), with_clauses ++ [opts]}
     {ast, ctx}
   end
 
@@ -1522,7 +1535,7 @@ defmodule CljElixir.Transformer do
   # 18. receive
   # ---------------------------------------------------------------------------
 
-  defp transform_receive(clauses, _meta, ctx) do
+  defp transform_receive(clauses, meta, ctx) do
     pattern_ctx = %{ctx | in_pattern: true}
 
     {case_clauses, after_clause} = parse_receive_clauses(clauses)
@@ -1556,7 +1569,7 @@ defmodule CljElixir.Transformer do
           opts ++ [after: [{:->, [], [[timeout_ast], body_ast]}]]
       end
 
-    ast = {:receive, [], [opts]}
+    ast = {:receive, elixir_meta(meta), [opts]}
     {ast, ctx}
   end
 
@@ -1628,21 +1641,21 @@ defmodule CljElixir.Transformer do
   # 19. for / doseq
   # ---------------------------------------------------------------------------
 
-  defp transform_for([{:vector, _, bindings} | body], _meta, ctx) do
+  defp transform_for([{:vector, _, bindings} | body], meta, ctx) do
     {generators, filters} = parse_comprehension_bindings(bindings, ctx)
     body_ast = transform_body(body, ctx)
 
     args = generators ++ filters ++ [[do: body_ast]]
-    ast = {:for, [], args}
+    ast = {:for, elixir_meta(meta), args}
     {ast, ctx}
   end
 
-  defp transform_doseq([{:vector, _, bindings} | body], _meta, ctx) do
+  defp transform_doseq([{:vector, _, bindings} | body], meta, ctx) do
     {generators, filters} = parse_comprehension_bindings(bindings, ctx)
     body_ast = transform_body(body, ctx)
 
     args = generators ++ filters ++ [[do: body_ast]]
-    ast = {:for, [], args}
+    ast = {:for, elixir_meta(meta), args}
     {ast, ctx}
   end
 
@@ -1991,6 +2004,111 @@ defmodule CljElixir.Transformer do
     {ast, ctx}
   end
 
+  # (pr-str val) -> CljElixir.Printer.pr_str(val)
+  # (pr-str a b c) -> join pr_str of each with space
+  defp transform_pr_str(args, ctx) do
+    t_args = Enum.map(args, fn a -> transform(a, ctx) end)
+    printer_mod = {:__aliases__, [alias: false], [:CljElixir, :Printer]}
+
+    case t_args do
+      [single] ->
+        ast = {{:., [], [printer_mod, :pr_str]}, [], [single]}
+        {ast, ctx}
+
+      multiple ->
+        strs =
+          Enum.map(multiple, fn a ->
+            {{:., [], [printer_mod, :pr_str]}, [], [a]}
+          end)
+
+        joined =
+          Enum.reduce(tl(strs), hd(strs), fn s, acc ->
+            {:<>, [], [acc, {:<>, [], [" ", s]}]}
+          end)
+
+        {joined, ctx}
+    end
+  end
+
+  # (pr val) -> IO.write(CljElixir.Printer.pr_str(val))
+  # Multiple args separated by spaces
+  defp transform_pr(args, ctx) do
+    t_args = Enum.map(args, fn a -> transform(a, ctx) end)
+    printer_mod = {:__aliases__, [alias: false], [:CljElixir, :Printer]}
+    io_mod = {:__aliases__, [alias: false], [:IO]}
+
+    writes =
+      t_args
+      |> Enum.with_index()
+      |> Enum.flat_map(fn {a, i} ->
+        pr_call = {{:., [], [printer_mod, :pr_str]}, [], [a]}
+        write_call = {{:., [], [io_mod, :write]}, [], [pr_call]}
+
+        if i > 0 do
+          space_call = {{:., [], [io_mod, :write]}, [], [" "]}
+          [space_call, write_call]
+        else
+          [write_call]
+        end
+      end)
+
+    ast = {:__block__, [], writes}
+    {ast, ctx}
+  end
+
+  # (prn val) -> IO.puts(CljElixir.Printer.pr_str(val))
+  # Multiple args joined with spaces, then newline
+  defp transform_prn(args, ctx) do
+    t_args = Enum.map(args, fn a -> transform(a, ctx) end)
+    printer_mod = {:__aliases__, [alias: false], [:CljElixir, :Printer]}
+    io_mod = {:__aliases__, [alias: false], [:IO]}
+
+    strs =
+      Enum.map(t_args, fn a ->
+        {{:., [], [printer_mod, :pr_str]}, [], [a]}
+      end)
+
+    joined =
+      case strs do
+        [single] ->
+          single
+
+        multiple ->
+          Enum.reduce(tl(multiple), hd(multiple), fn s, acc ->
+            {:<>, [], [acc, {:<>, [], [" ", s]}]}
+          end)
+      end
+
+    ast = {{:., [], [io_mod, :puts]}, [], [joined]}
+    {ast, ctx}
+  end
+
+  # (print-str val) -> CljElixir.Printer.print_str(val)
+  # (print-str a b c) -> join print_str of each with space
+  defp transform_print_str(args, ctx) do
+    t_args = Enum.map(args, fn a -> transform(a, ctx) end)
+    printer_mod = {:__aliases__, [alias: false], [:CljElixir, :Printer]}
+
+    case t_args do
+      [single] ->
+        ast = {{:., [], [printer_mod, :print_str]}, [], [single]}
+        {ast, ctx}
+
+      multiple ->
+        strs =
+          Enum.map(multiple, fn a ->
+            {{:., [], [printer_mod, :print_str]}, [], [a]}
+          end)
+
+        joined =
+          Enum.reduce(tl(strs), hd(strs), fn s, acc ->
+            {:<>, [], [acc, {:<>, [], [" ", s]}]}
+          end)
+
+        {joined, ctx}
+    end
+  end
+
   # nil?
   defp transform_nil_check([a], ctx) do
     a_ast = transform(a, ctx)
@@ -2034,25 +2152,27 @@ defmodule CljElixir.Transformer do
   # Positional constructor: (->Name arg1 arg2 ...)
   # ---------------------------------------------------------------------------
 
-  defp transform_positional_constructor(name, args, ctx) do
+  defp transform_positional_constructor(name, args, meta, ctx) do
     # "->Name" → strip ->
     record_name = String.slice(name, 2..-1//1)
     mod_alias = parse_module_name(record_name)
     t_args = Enum.map(args, fn a -> transform(a, ctx) end)
+    em = elixir_meta(meta)
 
     # Call Module.new(args...)
-    ast = {{:., [], [mod_alias, :new]}, [], t_args}
+    ast = {{:., em, [mod_alias, :new]}, em, t_args}
     {ast, ctx}
   end
 
   # Map constructor: (map->Name {:field val ...})
-  defp transform_map_constructor(name, args, ctx) do
+  defp transform_map_constructor(name, args, meta, ctx) do
     record_name = String.slice(name, 5..-1//1)
     mod_alias = parse_module_name(record_name)
     t_args = Enum.map(args, fn a -> transform(a, ctx) end)
+    em = elixir_meta(meta)
 
     # Use Kernel.struct!/2
-    ast = {{:., [], [{:__aliases__, [alias: false], [:Kernel]}, :struct!]}, [], [mod_alias | t_args]}
+    ast = {{:., em, [{:__aliases__, [alias: false], [:Kernel]}, :struct!]}, em, [mod_alias | t_args]}
     {ast, ctx}
   end
 
@@ -2822,7 +2942,7 @@ defmodule CljElixir.Transformer do
   # ---------------------------------------------------------------------------
 
   # (try body... (catch ...) ... (finally ...))
-  defp transform_try(args, _meta, ctx) do
+  defp transform_try(args, meta, ctx) do
     {body_forms, catch_clauses, finally_clause} = partition_try_args(args)
 
     # Transform body
@@ -2858,7 +2978,7 @@ defmodule CljElixir.Transformer do
           try_opts ++ [after: after_ast]
       end
 
-    ast = {:try, [], [try_opts]}
+    ast = {:try, elixir_meta(meta), [try_opts]}
     {ast, ctx}
   end
 
@@ -3274,4 +3394,17 @@ defmodule CljElixir.Transformer do
     |> String.replace("-", "_")
     |> String.to_atom()
   end
+
+  # ---------------------------------------------------------------------------
+  # Source-mapping: CljElixir meta → Elixir AST metadata
+  # ---------------------------------------------------------------------------
+
+  # Convert CljElixir meta map to Elixir AST keyword list metadata.
+  # Line must be >= 1 for the Erlang compiler annotation layer;
+  # a zero line/col is treated as absent.
+  defp elixir_meta(%{line: line, col: col}) when line > 0 and col > 0,
+    do: [line: line, column: col]
+  defp elixir_meta(%{line: line}) when line > 0,
+    do: [line: line]
+  defp elixir_meta(_), do: []
 end

lib/mix/tasks/clje.nrepl.ex

@@ -0,0 +1,36 @@
+defmodule Mix.Tasks.Clje.Nrepl do
+  @moduledoc """
+  Starts an nREPL server for CljElixir.
+
+  ## Usage
+
+      mix clje.nrepl              # random port
+      mix clje.nrepl --port 7888  # specific port
+
+  Writes port to `.nrepl-port` file for editor auto-discovery.
+  """
+
+  use Mix.Task
+
+  @shortdoc "Start a CljElixir nREPL server"
+
+  @impl Mix.Task
+  def run(args) do
+    {opts, _, _} = OptionParser.parse(args, strict: [port: :integer])
+    port = Keyword.get(opts, :port, 0)
+
+    Mix.Task.run("compile")
+    Mix.Task.run("app.start")
+
+    {:ok, server} = CljElixir.NRepl.Server.start_link(port: port)
+    actual_port = CljElixir.NRepl.Server.port(server)
+
+    File.write!(".nrepl-port", Integer.to_string(actual_port))
+
+    IO.puts("nREPL server started on port #{actual_port} on host 127.0.0.1")
+    IO.puts("Port written to .nrepl-port")
+    IO.puts("Press Ctrl+C to stop\n")
+
+    Process.sleep(:infinity)
+  end
+end

lib/mix/tasks/clje.repl.ex

@@ -0,0 +1,136 @@
+defmodule Mix.Tasks.Clje.Repl do
+  @moduledoc """
+  Starts an interactive CljElixir REPL.
+
+  ## Usage
+
+      mix clje.repl
+
+  Features:
+  - Full line editing (arrow keys, home/end, backspace)
+  - Multi-line input (auto-detects unbalanced parens)
+  - `pr-str` output formatting
+  - Bindings persist across evaluations
+  - Special commands: :quit, :history, :help
+
+  For readline-style history (up/down arrow recall), run with rlwrap:
+
+      rlwrap mix clje.repl
+  """
+
+  use Mix.Task
+
+  @shortdoc "Start an interactive CljElixir REPL"
+
+  @impl Mix.Task
+  def run(_args) do
+    # Ensure the project is compiled first
+    Mix.Task.run("compile")
+
+    # Start the application
+    Mix.Task.run("app.start")
+
+    IO.puts("CljElixir REPL v0.1.0")
+    IO.puts("Type :help for help, :quit to exit\n")
+
+    state = CljElixir.REPL.new()
+    loop(state)
+  end
+
+  defp loop(state) do
+    prompt = "clje:#{state.counter}> "
+
+    case read_input(prompt) do
+      :eof ->
+        IO.puts("\nBye!")
+
+      input ->
+        input = String.trim(input)
+
+        case input do
+          ":quit" ->
+            IO.puts("Bye!")
+
+          ":history" ->
+            print_history(state)
+            loop(state)
+
+          ":help" ->
+            print_help()
+            loop(state)
+
+          "" ->
+            loop(state)
+
+          _ ->
+            # Check for multi-line - read more if unbalanced
+            full_input = maybe_read_more(input)
+
+            case CljElixir.REPL.eval(full_input, state) do
+              {:ok, result_str, new_state} ->
+                IO.puts(result_str)
+                loop(new_state)
+
+              {:error, error_str, new_state} ->
+                IO.puts("\e[31m#{error_str}\e[0m")
+                loop(new_state)
+            end
+        end
+    end
+  end
+
+  defp read_input(prompt) do
+    case IO.gets(prompt) do
+      :eof -> :eof
+      {:error, _} -> :eof
+      data -> data
+    end
+  end
+
+  defp maybe_read_more(input) do
+    if CljElixir.REPL.balanced?(input) do
+      input
+    else
+      read_continuation(input)
+    end
+  end
+
+  defp read_continuation(acc) do
+    case IO.gets("       ") do
+      :eof -> acc
+      {:error, _} -> acc
+      line ->
+        new_acc = acc <> "\n" <> String.trim_trailing(line, "\n")
+
+        if CljElixir.REPL.balanced?(new_acc) do
+          new_acc
+        else
+          read_continuation(new_acc)
+        end
+    end
+  end
+
+  defp print_history(state) do
+    state.history
+    |> Enum.reverse()
+    |> Enum.with_index(1)
+    |> Enum.each(fn {expr, i} ->
+      IO.puts("  #{i}: #{String.replace(expr, "\n", "\n     ")}")
+    end)
+  end
+
+  defp print_help do
+    IO.puts("""
+    CljElixir REPL Commands:
+      :help     - show this help
+      :history  - show expression history
+      :quit     - exit the REPL
+
+    Tips:
+      - Multi-line input: unbalanced parens trigger continuation
+      - Bindings persist: (def x 42) makes x available in later expressions
+      - All CljElixir syntax is supported
+      - For up/down arrow history, run: rlwrap mix clje.repl
+    """)
+  end
+end