fix(nrepl): resolve the filesystem classpath for nREPL sessions (D-322)

Smell-audited: 1: the `-cp`-wins-else-$CLJW_PATH-else-"." rule was
about to be spelled a third time in the nrepl branch — folded into one
`resolveClasspath` instead, with `resolveDefaultClasspath` as its no-flags
call.

`cljw nrepl` rejected `-cp`, ignored $CLJW_PATH, and never called
require_resolver.installChained, so a connected editor could evaluate `(+ 1 2)`
but could not `(require '[my.lib])` from the project it was started in. D-322
landed the filesystem require chain on repl.run; the nREPL server was not
carried along, which left the one entry point where the user is certain to be
on a project as the only one without a classpath.

The nrepl branch now parses `[-cp <dirs>] [-A:alias…]` alongside `--port` and
threads `load_paths` + `fs_jail_root` into nrepl.run, which installs them
exactly as repl.zig does.

test/e2e/phase14_nrepl_classpath.sh covers one case per rung of the ADR-0084
rule (`-cp`, $CLJW_PATH, ./deps.edn :paths off the cwd) plus a negative case
pinning that the arg loop still rejects unknown flags.

Author: BuddhiLW

src/app/cli.zig

@@ -137,9 +137,14 @@ pub fn dispatch(init: std.process.Init) !void {
             return;
         }
         if (std.mem.eql(u8, first, "nrepl")) {
-            // nREPL server (ADR-0048). Optional `--port N`
-            // (default 7888 per JVM nREPL convention).
+            // nREPL server (ADR-0048). Optional `--port N` (default 7888 per
+            // JVM nREPL convention), plus the same `[-cp <dirs>] [-A:alias…]`
+            // classpath surface every other entry point carries (D-322): an
+            // editor session is the one place the user is CERTAIN to be on a
+            // project, so `(require '[my.lib])` must resolve off disk there.
             var port: u16 = 7888;
+            var nrepl_cp: ?[]const u8 = null;
+            var nrepl_aliases: std.ArrayList([]const u8) = .empty;
             while (args.next()) |a| {
                 if (std.mem.eql(u8, a, "--port")) {
                     const p_str = args.next() orelse {
@@ -152,13 +157,25 @@ pub fn dispatch(init: std.process.Init) !void {
                         try stderr.flush();
                         std.process.exit(1);
                     };
+                } else if (std.mem.eql(u8, a, "-cp") or std.mem.eql(u8, a, "--classpath")) {
+                    nrepl_cp = args.next() orelse {
+                        try stderr.print("nrepl: -cp requires an argument\n", .{});
+                        try stderr.flush();
+                        std.process.exit(1);
+                    };
+                } else if (std.mem.startsWith(u8, a, "-A")) {
+                    var it = std.mem.splitScalar(u8, a[2..], ':');
+                    while (it.next()) |name| {
+                        if (name.len > 0) try nrepl_aliases.append(arena, name);
+                    }
                 } else {
                     try stderr.print("nrepl: unknown argument '{s}'\n", .{a});
                     try stderr.flush();
                     std.process.exit(1);
                 }
             }
-            return nrepl.run(io, gpa, arena, stdout, stderr, port);
+            const load_paths = try resolveClasspath(io, arena, stderr, nrepl_cp, cljw_path, nrepl_aliases.items, git_cache_base);
+            return nrepl.run(io, gpa, arena, stdout, stderr, port, load_paths, fs_jail_root);
         }
         if (std.mem.eql(u8, first, "build")) {
             // D-100(b) + ADR-0034 am3/am4: `cljw build <in.clj> -o <out>` (script
@@ -339,8 +356,10 @@ fn dispatchArgsRest(
                 \\
                 \\Subcommands:
                 \\  repl               Start a terminal REPL.
-                \\  nrepl [--port N]   Start an nREPL server (default port 7888) for
-                \\                     CIDER and other editors.
+                \\  nrepl [--port N] [-cp <dirs>] [-A:alias…]
+                \\                     Start an nREPL server (default port 7888) for
+                \\                     CIDER and other editors. Classpath resolves as
+                \\                     for a run: `-cp` wins, else $CLJW_PATH, else ".".
                 \\  build <in.clj> -o <out> [-cp <dirs>] [-A:alias…]
                 \\                     Compile a script (with the runtime) into one
                 \\                     self-contained native binary. Main-mode variant:
@@ -495,17 +514,30 @@ fn loadDepsEdn(io: std.Io, arena: std.mem.Allocator, stderr: *std.Io.Writer, bas
     return .{ .load_paths = try merged.toOwnedSlice(arena), .cfg = cfg };
 }
 
-/// The default classpath for a no-`-cp` REPL entry (the `repl` subcommand + the
-/// bare no-args fallback): `$CLJW_PATH` (else cwd ".") split into roots, with a
-/// `./deps.edn` `:paths`/source-deps prepended. Mirrors `dispatchArgsRest`'s
-/// resolution minus the `-cp` flag + `-A` aliases, so the classpath-resolution
-/// behaviour lives in one place rather than duplicated per REPL entry (F-011).
-fn resolveDefaultClasspath(io: std.Io, arena: std.mem.Allocator, stderr: *std.Io.Writer, cljw_path_env: ?[]const u8, git_cache_base: ?[]const u8) ![]const []const u8 {
-    const base_paths = try splitClasspath(arena, cljw_path_env orelse ".");
-    const deps = try loadDepsEdn(io, arena, stderr, base_paths, &.{}, git_cache_base);
+/// The classpath for a REPL-shaped entry (`repl`, `nrepl`, the bare no-args
+/// fallback), resolved by the ADR-0084 rule: `-cp` wins, else `$CLJW_PATH`,
+/// else cwd ".", split into roots with a `./deps.edn` `:paths`/source-deps
+/// prepended. Mirrors `dispatchArgsRest`'s resolution so the rule lives in one
+/// place rather than duplicated per entry point (F-011).
+fn resolveClasspath(
+    io: std.Io,
+    arena: std.mem.Allocator,
+    stderr: *std.Io.Writer,
+    classpath_arg: ?[]const u8,
+    cljw_path_env: ?[]const u8,
+    alias_names: []const []const u8,
+    git_cache_base: ?[]const u8,
+) ![]const []const u8 {
+    const base_paths = try splitClasspath(arena, classpath_arg orelse cljw_path_env orelse ".");
+    const deps = try loadDepsEdn(io, arena, stderr, base_paths, alias_names, git_cache_base);
     return deps.load_paths;
 }
 
+/// `resolveClasspath` for an entry that takes neither `-cp` nor `-A`.
+fn resolveDefaultClasspath(io: std.Io, arena: std.mem.Allocator, stderr: *std.Io.Writer, cljw_path_env: ?[]const u8, git_cache_base: ?[]const u8) ![]const []const u8 {
+    return resolveClasspath(io, arena, stderr, null, cljw_path_env, &.{}, git_cache_base);
+}
+
 /// Split a colon-separated classpath string into its directory roots, allocated
 /// in `arena`. Empty segments are dropped; an all-empty spec yields `["."]`.
 fn splitClasspath(arena: std.mem.Allocator, spec: []const u8) ![]const []const u8 {

src/app/nrepl.zig

@@ -28,6 +28,7 @@ const std = @import("std");
 const Writer = std.Io.Writer;
 
 const bootstrap = @import("../lang/bootstrap.zig");
+const require_resolver = @import("../lang/require_resolver.zig");
 const macro_dispatch = @import("../eval/macro_dispatch.zig");
 const driver = @import("../eval/driver.zig");
 const Runtime = @import("../runtime/runtime.zig").Runtime;
@@ -46,6 +47,13 @@ pub fn run(
     stdout: *Writer,
     stderr: *Writer,
     port: u16,
+    /// Filesystem classpath the sessions' `(require …)` searches, so an editor
+    /// resolves project libs off disk exactly as a file/`-e` run does (D-322).
+    /// Mirrors `repl.run`.
+    load_paths: []const []const u8,
+    /// Deploy-mode FS jail root (`CLJW_FS_ROOT`), or null for an unconfined
+    /// local server (ADR-0123 / SE-6/7).
+    fs_jail_root: ?[]const u8,
 ) !void {
     // Address + bind. IpAddress.parseIp4 + listen are the Zig 0.16
     // canonical sync server pattern (cf. lib/std/Io/net.zig:246).
@@ -91,6 +99,13 @@ pub fn run(
         return err;
     };
 
+    // ADR-0084 / D-322: enable filesystem `require` for user libs, exactly as
+    // repl.zig does — setupCore* installs the embedded-only resolver, so swap
+    // to the embedded-FIRST chain + the classpath.
+    rt.load_paths = load_paths;
+    rt.fs_jail_root = fs_jail_root;
+    require_resolver.installChained(&rt);
+
     var registry = session_mod.Registry.init(gpa, &rt.gc, io);
     defer registry.deinit();
 

test/e2e/phase14_nrepl_classpath.sh

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+# test/e2e/phase14_nrepl_classpath.sh
+#
+# D-322 for the nREPL server: a session must resolve `(require '[my.lib])`
+# off the filesystem classpath, exactly as `cljw <file>` / `cljw -e` /
+# `cljw repl` do. Before this, `cljw nrepl` took no `-cp`, ignored
+# $CLJW_PATH, and never called require_resolver.installChained — so an
+# editor could evaluate arithmetic but could not load one line of the
+# project it was started in.
+#
+# Three cases, one per rung of the ADR-0084 resolution rule
+# (`-cp` wins, else $CLJW_PATH, else "." + ./deps.edn :paths):
+#   1. -cp <dir>
+#   2. $CLJW_PATH
+#   3. neither — ./deps.edn :paths off the cwd
+# plus a negative case pinning that unknown args are still rejected.
+#
+# Same harness shape as phase14_nrepl.sh: launch the server on a random
+# high port, drive bencode over a socket from python3, assert the
+# `value` frame.
+
+set -euo pipefail
+cd "$(dirname "$0")/../.."
+ROOT=$(pwd)
+
+BIN="$ROOT/zig-out/bin/cljw"
+[ -n "${CLJW_SKIP_BUILD:-}" ] || zig build -Dwasm -Doptimize="${CLJW_OPT:-ReleaseSafe}" >/dev/null
+
+WORK=$(mktemp -d)
+SERVER_PID=""
+cleanup() {
+    [[ -n "$SERVER_PID" ]] && kill "$SERVER_PID" 2>/dev/null || true
+    rm -rf "$WORK"
+}
+trap cleanup EXIT
+
+fail() { echo "FAIL $1" >&2; exit 1; }
+
+# A throwaway project: one namespace under src/, declared in deps.edn.
+mkdir -p "$WORK/src/cljw_cp_probe"
+cat > "$WORK/src/cljw_cp_probe/lib.clj" <<'EOF'
+(ns cljw-cp-probe.lib)
+(defn answer [] 42)
+EOF
+cat > "$WORK/deps.edn" <<'EOF'
+{:paths ["src"]}
+EOF
+
+# Drive one eval over bencode; echoes each `value` frame on its own line.
+drive() {
+    python3 - "$1" "$2" <<'PY'
+import socket, sys, time
+
+def encode(v):
+    if isinstance(v, int): return f"i{v}e".encode()
+    if isinstance(v, (bytes, str)):
+        b = v.encode() if isinstance(v, str) else v
+        return f"{len(b)}:".encode() + b
+    if isinstance(v, list): return b"l" + b"".join(encode(x) for x in v) + b"e"
+    if isinstance(v, dict):
+        out = b"d"
+        for k in sorted(v.keys()):
+            out += encode(k) + encode(v[k])
+        return out + b"e"
+    raise ValueError(type(v))
+
+def decode(buf, i=0):
+    c = buf[i:i+1]
+    if c == b"i":
+        j = buf.index(b"e", i); return int(buf[i+1:j]), j+1
+    if c.isdigit():
+        j = buf.index(b":", i); n = int(buf[i:j]); return buf[j+1:j+1+n], j+1+n
+    if c == b"l":
+        i += 1; out = []
+        while buf[i:i+1] != b"e":
+            v, i = decode(buf, i); out.append(v)
+        return out, i+1
+    if c == b"d":
+        i += 1; out = {}
+        while buf[i:i+1] != b"e":
+            k, i = decode(buf, i); v, i = decode(buf, i); out[k.decode()] = v
+        return out, i+1
+    raise ValueError(buf[i:i+4])
+
+port, code = int(sys.argv[1]), sys.argv[2]
+s = socket.create_connection(("127.0.0.1", port), timeout=5)
+s.settimeout(5)
+s.sendall(encode({"op": "eval", "code": code, "id": "1"}))
+buf, t0 = b"", time.time()
+while time.time() - t0 < 5:
+    try:
+        chunk = s.recv(4096)
+    except socket.timeout:
+        break
+    if not chunk: break
+    buf += chunk
+    if b"done" in buf: break
+i = 0
+while i < len(buf):
+    try:
+        m, i = decode(buf, i)
+    except Exception:
+        break
+    if "value" in m: print(m["value"].decode())
+    if "err" in m: print("ERR " + m["err"].decode().replace("\n", " "))
+PY
+}
+
+# Start a server in $WORK and wait for its port file. $1 = port, rest = argv.
+start_server() {
+    local port="$1"; shift
+    rm -f "$WORK/.nrepl-port"
+    ( cd "$WORK" && "$BIN" nrepl --port "$port" "$@" >"$WORK/out.log" 2>&1 ) &
+    SERVER_PID=$!
+    local deadline=$((SECONDS + 10))
+    while [[ ! -f "$WORK/.nrepl-port" ]] && [[ $SECONDS -lt $deadline ]]; do sleep 0.1; done
+    [[ -f "$WORK/.nrepl-port" ]] || fail "server did not bind within 10s: $(cat "$WORK/out.log")"
+}
+
+stop_server() {
+    kill "$SERVER_PID" 2>/dev/null || true
+    wait "$SERVER_PID" 2>/dev/null || true
+    SERVER_PID=""
+    sleep 0.2
+}
+
+CODE='(require (quote [cljw-cp-probe.lib :as p])) (p/answer)'
+
+# --- Case 1: -cp <dir> ---
+PORT=$(( 19100 + (RANDOM % 300) ))
+start_server "$PORT" -cp src
+got=$(drive "$PORT" "$CODE" | tail -1)
+stop_server
+[[ "$got" == "42" ]] || fail "nrepl_cp_flag: expected 42, got '$got'"
+echo "PASS nrepl_cp_flag -> 42"
+
+# --- Case 2: $CLJW_PATH ---
+PORT=$(( 19400 + (RANDOM % 300) ))
+CLJW_PATH=src start_server "$PORT"
+got=$(drive "$PORT" "$CODE" | tail -1)
+stop_server
+[[ "$got" == "42" ]] || fail "nrepl_cljw_path_env: expected 42, got '$got'"
+echo "PASS nrepl_cljw_path_env -> 42"
+
+# --- Case 3: neither — ./deps.edn :paths off the cwd ---
+PORT=$(( 19700 + (RANDOM % 300) ))
+start_server "$PORT"
+got=$(drive "$PORT" "$CODE" | tail -1)
+stop_server
+[[ "$got" == "42" ]] || fail "nrepl_deps_edn_paths: expected 42, got '$got'"
+echo "PASS nrepl_deps_edn_paths -> 42"
+
+# --- Case 4: unknown args are still rejected (the parse loop stays closed) ---
+if "$BIN" nrepl --bogus >"$WORK/bogus.log" 2>&1; then
+    fail "nrepl_unknown_arg: --bogus was accepted"
+fi
+grep -q "unknown argument" "$WORK/bogus.log" || fail "nrepl_unknown_arg: no diagnostic: $(cat "$WORK/bogus.log")"
+echo "PASS nrepl_unknown_arg -> rejected"
+
+echo "ALL PASS test/e2e/phase14_nrepl_classpath.sh"

test/run_all.sh

@@ -533,6 +533,7 @@ run_step "e2e_phase14_future_promise_delay"  "bash test/e2e/phase14_future_promi
 run_step "e2e_phase14_repl"                  "bash test/e2e/phase14_repl.sh"
 run_step "e2e_phase14_nrepl"                 "bash test/e2e/phase14_nrepl.sh"
 run_step "e2e_phase14_nrepl_completion"      "bash test/e2e/phase14_nrepl_completion.sh"
+run_step "e2e_phase14_nrepl_classpath"       "bash test/e2e/phase14_nrepl_classpath.sh"
 run_step "e2e_phase14_error_format"          "bash test/e2e/phase14_error_format.sh"
 run_step "e2e_phase14_render_error"          "bash test/e2e/phase14_render_error.sh"
 run_step "e2e_phase14_callable_print"        "bash test/e2e/phase14_callable_print.sh"